home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #2 / Amiga Plus CD - 2004 - No. 02.iso / AmiSoft / Disk / moni / FileX-src.lha / FileX-src / filexarexx_rxif.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-29  |  54.8 KB  |  2,933 lines
  1. /*
  2.  * Source generated with ARexxBox 1.11 (May  5 1993)
  3.  * which is Copyright (c) 1992,1993 Michael Balzer
  4.  *
  5.  * and heavily modified by Klaas Hermanns
  6.  */
  7.  
  8. #include <exec/types.h>
  9. #include <exec/memory.h>
  10. #include <dos/dos.h>
  11. #include <rexx/storage.h>
  12. #include <rexx/rxslib.h>
  13. #include <rexx/errors.h>
  14.  
  15. #include <clib/alib_protos.h>
  16. #include <clib/exec_protos.h>
  17. #include <clib/dos_protos.h>
  18. #include <clib/rexxsyslib_protos.h>
  19.  
  20. #include <pragmas/exec_pragmas.h>
  21. #include <pragmas/dos_pragmas.h>
  22. #include <pragmas/rexxsyslib_pragmas.h>
  23.  
  24. #include <stdlib.h>
  25. #include <stdio.h>
  26. #include <string.h>
  27. #include <ctype.h>
  28.  
  29. #include "FileXARexx.h"
  30.  
  31. #include "allprotos.h"
  32. #include "FileX.h"
  33. #include "FileXStructs.h"
  34. #include "FileXStrings.h"
  35.  
  36. /* ARexx Hilfsfunktionen */
  37.  
  38. BOOL ValidDD( struct DisplayData *DDD )
  39. {
  40.     struct DisplayData *DD;
  41.     struct DisplayInhalt *DI;
  42.  
  43.     DI = (struct DisplayInhalt *)DisplayInhaltList.lh_Head;
  44.  
  45.     while( DI != ( struct DisplayInhalt * )&DisplayInhaltList.lh_Tail )
  46.     {
  47.         DD = (struct DisplayData *)DI->DisplayList.lh_Head;
  48.  
  49.         while( DD != ( struct DisplayData * )&DI->DisplayList.lh_Tail )
  50.         {
  51.             if( DD == DDD )
  52.                 return( TRUE );
  53.  
  54.             DD = ( struct DisplayData *)DD->Node.ln_Succ;
  55.         }
  56.  
  57.         DI = ( struct DisplayInhalt *)DI->Node.ln_Succ;
  58.     }
  59.  
  60.     return( FALSE );
  61. }
  62.  
  63.  
  64. BOOL ValidDI( struct DisplayInhalt *DDI )
  65. {
  66.     struct DisplayInhalt *DI;
  67.  
  68.     DI = (struct DisplayInhalt *)DisplayInhaltList.lh_Head;
  69.  
  70.     while( DI != ( struct DisplayInhalt * )&DisplayInhaltList.lh_Tail )
  71.     {
  72.         if( DI == DDI )
  73.             return( TRUE );
  74.  
  75.         DI = ( struct DisplayInhalt *)DI->Node.ln_Succ;
  76.     }
  77.  
  78.     return( FALSE );
  79. }
  80.  
  81. BOOL ValidFD( struct FileData *FFD )
  82. {
  83.     struct FileData *FD;
  84.  
  85.     FD = (struct FileData *)FileList.lh_Head;
  86.  
  87.     while( FD != ( struct FileData * )&FileList.lh_Tail )
  88.     {
  89.         if( FD == FFD )
  90.             return( TRUE );
  91.  
  92.         FD = ( struct FileData *)FD->Node.ln_Succ;
  93.     }
  94.  
  95.     return( FALSE );
  96. }
  97.  
  98. /*************************/
  99.  
  100. #ifdef AREXX
  101.  
  102. void rx_clear( struct RexxHost *host, struct rxd_clear **rxd, long action )
  103. {
  104.     struct rxd_clear *rd = *rxd;
  105.     struct DisplayData *DD;
  106.  
  107.     if(( *rxd )->arg.id )
  108.     {
  109.         if( ValidDD( *( *rxd )->arg.id ))
  110.         {
  111.             DD = *( *rxd )->arg.id;
  112.         }
  113.         else
  114.         {
  115.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  116.             (*rxd)->rc = -RC_WARN;
  117.         }
  118.     }
  119.     else
  120.         DD = AktuDD;
  121.  
  122.     if( !(*rxd)->rc )
  123.     {
  124.         if(( rd->arg.force != FALSE ) || ( QuitView( 3, DD )))
  125.             ClearDDFile( DD, TRUE );
  126.         else
  127.             rd->rc=RC_WARN;
  128.     }
  129. }
  130.  
  131. void rx_open( struct RexxHost *host, struct rxd_open **rxd, long action )
  132. {
  133.     struct rxd_open *rd = *rxd;
  134.     BOOL Success = FALSE;
  135.     struct DisplayData *DD;
  136.  
  137.     if(( *rxd )->arg.id )
  138.     {
  139.         if( ValidDD( *( *rxd )->arg.id ))
  140.         {
  141.             DD = *( *rxd )->arg.id;
  142.         }
  143.         else
  144.         {
  145.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  146.             (*rxd)->rc = -RC_WARN;
  147.         }
  148.     }
  149.     else
  150.         DD = AktuDD;
  151.  
  152.     if( !(*rxd)->rc )
  153.     {
  154.         if(( rd->arg.force != FALSE ) || ( QuitView( 5, DD )))
  155.         {
  156.             if( rd->arg.filename )
  157.                 Success = MyOpen( rd->arg.filename, DD );
  158.             else
  159.                 Success = OpenFile( DD );
  160.         }
  161.     
  162.         if( !Success )
  163.             rd->rc=RC_WARN;
  164.     }
  165. }
  166.  
  167. void rx_print( struct RexxHost *host, struct rxd_print **rxd, long action )
  168. {
  169.     struct FileData *FD;
  170.  
  171.     if(( *rxd )->arg.id )
  172.     {
  173.         if( ValidFD( *( *rxd )->arg.id ))
  174.         {
  175.             FD = *( *rxd )->arg.id;
  176.         }
  177.         else
  178.         {
  179.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  180.             (*rxd)->rc = -RC_WARN;
  181.         }
  182.     }
  183.     else
  184.         FD = AktuDD->FD;
  185.  
  186.     if( !(*rxd)->rc )
  187.         PrintFile( FD );
  188. }
  189.  
  190. void rx_quit( struct RexxHost *host, struct rxd_quit **rxd, long action )
  191. {
  192.     struct rxd_quit *rd = *rxd;
  193.  
  194.     if(( rd->arg.force != FALSE ) || ( QuitRequester( 0, 0 )))
  195.     {
  196.         mainflags |= MF_ENDE;
  197.     }
  198.     else
  199.         rd->rc = RC_WARN;
  200. }
  201.  
  202. void rx_save( struct RexxHost *host, struct rxd_save **rxd, long action )
  203. {
  204.     struct rxd_save *rd = *rxd;
  205.     struct FileData *FD;
  206.  
  207.     if(( *rxd )->arg.id )
  208.     {
  209.         if( ValidFD( *( *rxd )->arg.id ))
  210.         {
  211.             FD = *( *rxd )->arg.id;
  212.         }
  213.         else
  214.         {
  215.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  216.             (*rxd)->rc = -RC_WARN;
  217.         }
  218.     }
  219.     else
  220.         FD = AktuDD->FD;
  221.  
  222.     if( !(*rxd)->rc )
  223.     {
  224.         if( SaveFile( FD ))
  225.             rd->rc = 0;
  226.         else
  227.             rd->rc = RC_WARN;
  228.     }
  229. }
  230.  
  231. void rx_saveas( struct RexxHost *host, struct rxd_saveas **rxd, long action )
  232. {
  233.     struct rxd_saveas *rd = *rxd;
  234.     BOOL Success;
  235.     struct FileData *FD;
  236.  
  237.     if(( *rxd )->arg.id )
  238.     {
  239.         if( ValidFD( *( *rxd )->arg.id ))
  240.         {
  241.             FD = *( *rxd )->arg.id;
  242.         }
  243.         else
  244.         {
  245.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  246.             (*rxd)->rc = -RC_WARN;
  247.         }
  248.     }
  249.     else
  250.         FD = AktuDD->FD;
  251.  
  252.     if( !(*rxd)->rc )
  253.     {
  254.         if( rd->arg.name )
  255.         {
  256.             Success = SaveNewName( rd->arg.name, FD );
  257.         }
  258.         else
  259.             Success = SaveAsFile( FD );
  260.     
  261.         if( Success )
  262.             rd->rc = 0;
  263.         else
  264.             rd->rc = RC_WARN;
  265.     }
  266. }
  267.  
  268. void rx_nop( struct RexxHost *host, struct rxd_nop **rxd, long action )
  269. {
  270.     /* Nichts :-) */
  271. }
  272.  
  273. void rx_requestnotify( struct RexxHost *host, struct rxd_requestnotify **rxd, long action )
  274. {
  275.     struct rxd_requestnotify *rd = *rxd;
  276.  
  277.     if( rd->arg.prompt )
  278.         MyRequestNoLocale( rd->arg.prompt, 0 );
  279.     else
  280.         DisplayLocaleText( MSG_INFO_AREXX_NOTIFY );
  281. }
  282.  
  283. void rx_requestresponse( struct RexxHost *host, struct rxd_requestresponse **rxd, long action )
  284. {
  285.     struct rxd_requestresponse *rd = *rxd;
  286.  
  287.     if( !rd->arg.buttons )
  288.         rd->arg.buttons = GetStr( MSG_GADGET_YESNO );
  289.  
  290.     rd->rc = MyFullRequestNoLocale( rd->arg.prompt, rd->arg.buttons, 0 );
  291. }
  292.  
  293. void rx_requeststring( struct RexxHost *host, struct rxd_requeststring **rxd, long action )
  294. {
  295.     struct rxd_requeststring *rd = *rxd;
  296.  
  297.     switch( action )
  298.     {
  299.         case RXIF_INIT:
  300.             rd->res.string = AllocVec(256,MEMF_ANY);
  301.             *rd->res.string = 0;
  302.             break;
  303.             
  304.         case RXIF_ACTION:
  305.             if( rd->arg.mydefault )
  306.                 strcpy(rd->res.string,rd->arg.mydefault);
  307.  
  308.             if( 0 == MyGetString( rd->res.string, rd->arg.prompt, 256 ))
  309.                 rd->rc=RC_WARN;
  310.             else
  311.                 rd->rc=0;
  312.  
  313.             break;
  314.         
  315.         case RXIF_FREE:
  316.             FreeVec(rd->res.string);
  317.             break;
  318.     }
  319. }
  320.  
  321. void rx_column( struct RexxHost *host, struct rxd_column **rxd, long action )
  322. {
  323.     struct rxd_column *rd = *rxd;
  324.     struct DisplayData *DD;
  325.  
  326.     if(( *rxd )->arg.id )
  327.     {
  328.         if( ValidDD( *( *rxd )->arg.id ))
  329.         {
  330.             DD = *( *rxd )->arg.id;
  331.         }
  332.         else
  333.         {
  334.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  335.             (*rxd)->rc = -RC_WARN;
  336.         }
  337.     }
  338.     else
  339.         DD = AktuDD;
  340.  
  341.     if( rd->arg.delta )
  342.         MoveCursorX( *rd->arg.delta, DD );
  343. }
  344.  
  345. void rx_cursor( struct RexxHost *host, struct rxd_cursor **rxd, long action )
  346. {
  347.     struct rxd_cursor *rd = *rxd;
  348.     struct DisplayData *DD;
  349.  
  350.     if(( *rxd )->arg.id )
  351.     {
  352.         if( ValidDD( *( *rxd )->arg.id ))
  353.         {
  354.             DD = *( *rxd )->arg.id;
  355.         }
  356.         else
  357.         {
  358.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  359.             (*rxd)->rc = -RC_WARN;
  360.         }
  361.     }
  362.     else
  363.         DD = AktuDD;
  364.  
  365.     if( !(*rxd)->rc )
  366.     {
  367.         if( rd->arg.up != FALSE )
  368.             MoveCursorY( -1, DD );
  369.         else
  370.             if( rd->arg.down != FALSE )
  371.                 MoveCursorY( 1, DD );
  372.     
  373.         if( rd->arg.left != FALSE )
  374.             MoveCursorX( -1, DD );
  375.         else
  376.             if( rd->arg.right != FALSE )
  377.                 MoveCursorX( 1, DD );
  378.     }
  379. }
  380.  
  381. void rx_gotobookmark( struct RexxHost *host, struct rxd_gotobookmark **rxd, long action )
  382. {
  383.     struct rxd_gotobookmark *rd = *rxd;
  384.  
  385.     struct DisplayData *DD;
  386.  
  387.     if(( *rxd )->arg.id )
  388.     {
  389.         if( ValidDD( *( *rxd )->arg.id ))
  390.         {
  391.             DD = *( *rxd )->arg.id;
  392.         }
  393.         else
  394.         {
  395.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  396.             (*rxd)->rc = -RC_WARN;
  397.         }
  398.     }
  399.     else
  400.         DD = AktuDD;
  401.  
  402.     if( !(*rxd)->rc )
  403.     {
  404.         if(( *rd->arg.number > 0 ) && ( *rd->arg.number <= 10 ))
  405.         {
  406.             JumpToLocation( *rd->arg.number, DD );
  407.             rd->rc = 0;
  408.         }
  409.         else
  410.             rd->rc = RC_WARN;
  411.     }
  412. }
  413.  
  414. void rx_gotocolumn( struct RexxHost *host, struct rxd_gotocolumn **rxd, long action )
  415. {
  416.     struct rxd_gotocolumn *rd = *rxd;
  417.     struct DisplayData *DD;
  418.  
  419.     if(( *rxd )->arg.id )
  420.     {
  421.         if( ValidDD( *( *rxd )->arg.id ))
  422.         {
  423.             DD = *( *rxd )->arg.id;
  424.         }
  425.         else
  426.         {
  427.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  428.             (*rxd)->rc = -RC_WARN;
  429.         }
  430.     }
  431.     else
  432.         DD = AktuDD;
  433.  
  434.     if( !(*rxd)->rc )
  435.         SetCursorX( *rd->arg.column, DD );
  436. }
  437.  
  438. void rx_gotoline( struct RexxHost *host, struct rxd_gotoline **rxd, long action )
  439. {
  440.     struct rxd_gotoline *rd = *rxd;
  441.     struct DisplayData *DD;
  442.  
  443.     if(( *rxd )->arg.id )
  444.     {
  445.         if( ValidDD( *( *rxd )->arg.id ))
  446.         {
  447.             DD = *( *rxd )->arg.id;
  448.         }
  449.         else
  450.         {
  451.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  452.             (*rxd)->rc = -RC_WARN;
  453.         }
  454.     }
  455.     else
  456.         DD = AktuDD;
  457.  
  458.     if( !(*rxd)->rc )
  459.         SetCursorY( *rd->arg.line, DD );
  460. }
  461.  
  462. void rx_line( struct RexxHost *host, struct rxd_line **rxd, long action )
  463. {
  464.     struct rxd_line *rd = *rxd;
  465.     struct DisplayData *DD;
  466.  
  467.     if(( *rxd )->arg.id )
  468.     {
  469.         if( ValidDD( *( *rxd )->arg.id ))
  470.         {
  471.             DD = *( *rxd )->arg.id;
  472.         }
  473.         else
  474.         {
  475.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  476.             (*rxd)->rc = -RC_WARN;
  477.         }
  478.     }
  479.     else
  480.         DD = AktuDD;
  481.  
  482.     if( !(*rxd)->rc )
  483.         MoveCursorY( *rd->arg.delta, DD );
  484. }
  485.  
  486. void rx_position( struct RexxHost *host, struct rxd_position **rxd, long action )
  487. {
  488.     struct rxd_position *rd = *rxd;
  489.     struct DisplayData *DD;
  490.  
  491.     if(( *rxd )->arg.id )
  492.     {
  493.         if( ValidDD( *( *rxd )->arg.id ))
  494.         {
  495.             DD = *( *rxd )->arg.id;
  496.         }
  497.         else
  498.         {
  499.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  500.             (*rxd)->rc = -RC_WARN;
  501.         }
  502.     }
  503.     else
  504.         DD = AktuDD;
  505.  
  506.     if( !(*rxd)->rc )
  507.     {
  508.         if( rd->arg.sof != FALSE ) SetCursorStart( DD );
  509.         else if( rd->arg.eof != FALSE ) SetCursorEnd( DD );
  510.     
  511.         if( rd->arg.sol != FALSE ) SetCursorStartOfLine( DD );
  512.         else if( rd->arg.eol != FALSE ) SetCursorEndOfLine( DD );
  513.     }
  514. }
  515.  
  516. void rx_setbookmark( struct RexxHost *host, struct rxd_setbookmark **rxd, long action )
  517. {
  518.     struct rxd_setbookmark *rd = *rxd;
  519.     struct DisplayData *DD;
  520.  
  521.     if(( *rxd )->arg.id )
  522.     {
  523.         if( ValidDD( *( *rxd )->arg.id ))
  524.         {
  525.             DD = *( *rxd )->arg.id;
  526.         }
  527.         else
  528.         {
  529.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  530.             (*rxd)->rc = -RC_WARN;
  531.         }
  532.     }
  533.     else
  534.         DD = AktuDD;
  535.  
  536.     if( !(*rxd)->rc )
  537.     {
  538.         rd->rc=RC_WARN;
  539.     
  540.         if( rd->arg.number )
  541.             if(( *rd->arg.number > 0 ) && ( *rd->arg.number <= 10 ))
  542.             {
  543.                 MarkLocation( *rd->arg.number, DD );
  544.                 rd->rc = 0;
  545.             }
  546.     }
  547. }
  548.  
  549. void rx_find( struct RexxHost *host, struct rxd_find **rxd, long action )
  550. {
  551.     struct rxd_find *rd = *rxd;
  552.     struct DisplayData *DD;
  553.  
  554.     if(( *rxd )->arg.id )
  555.     {
  556.         if( ValidDD( *( *rxd )->arg.id ))
  557.         {
  558.             DD = *( *rxd )->arg.id;
  559.         }
  560.         else
  561.         {
  562.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  563.             (*rxd)->rc = -RC_WARN;
  564.         }
  565.     }
  566.     else
  567.         DD = AktuDD;
  568.  
  569.     if( !(*rxd)->rc )
  570.     {
  571.         searchmode &= ~SM_REPLACE;
  572.  
  573.         rd->rc = 0;
  574.     
  575.         if( rd->arg.text )
  576.         {
  577.             SetSearchString(rd->arg.text);
  578.     
  579.             if( rd->arg.hex != FALSE )
  580.                 searchmode&=~SM_STRING;
  581.             else
  582.                 searchmode|=SM_STRING;
  583.         }
  584.     
  585.         if( rd->arg.prompt != FALSE )
  586.         {
  587.             OpenSearchWindow( FALSE );
  588.         }
  589.         else
  590.         {
  591.             BOOL quiet = FALSE;
  592.     
  593.             if( rd->arg.quiet != FALSE )
  594.                 quiet = TRUE;
  595.     
  596.             if( rd->arg.backwards != FALSE )
  597.             {
  598.                 if(!(SearchNext(BM_BACKWARD,quiet,FALSE, DD)))
  599.                     rd->rc=RC_WARN;
  600.             }
  601.             else
  602.             {
  603.                 if(!SearchNext(0,quiet,FALSE, DD))
  604.                     rd->rc=RC_WARN;
  605.             }
  606.         }
  607.     }
  608. }
  609.  
  610. void rx_findchange( struct RexxHost *host, struct rxd_findchange **rxd, long action )
  611. {
  612.     struct rxd_findchange *rd = *rxd;
  613.     struct DisplayData *DD;
  614.  
  615.     if(( *rxd )->arg.id )
  616.     {
  617.         if( ValidDD( *( *rxd )->arg.id ))
  618.         {
  619.             DD = *( *rxd )->arg.id;
  620.         }
  621.         else
  622.         {
  623.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  624.             (*rxd)->rc = -RC_WARN;
  625.         }
  626.     }
  627.     else
  628.         DD = AktuDD;
  629.  
  630.     if( !(*rxd)->rc )
  631.     {
  632.         searchmode|=SM_REPLACE;
  633.     
  634.         rd->rc = 0;
  635.     
  636.         if(rd->arg.find)SetSearchString(rd->arg.find);
  637.         if(rd->arg.change)SetReplaceString(rd->arg.change);
  638.     
  639.         if(rd->arg.hex!=FALSE)
  640.             searchmode&=~SM_STRING;
  641.         else
  642.             searchmode|=SM_STRING;
  643.     
  644.         if(rd->arg.prompt!=FALSE)
  645.         {
  646.             OpenSearchWindow( TRUE );
  647.         }
  648.         else
  649.         {
  650.             BOOL quiet=FALSE,all=FALSE;
  651.     
  652.             if(rd->arg.quiet!=FALSE)quiet=TRUE;
  653.             if(rd->arg.all!=FALSE)all=TRUE;
  654.     
  655.             if(rd->arg.backwards!=FALSE)
  656.             {
  657.                 if(!(SearchNext(BM_BACKWARD,quiet,all,DD)))
  658.                     rd->rc=RC_WARN;
  659.             }
  660.             else
  661.             {
  662.                 if(!SearchNext(0,quiet,all,DD))
  663.                     rd->rc=RC_WARN;
  664.             }
  665.         }
  666.     }
  667. }
  668.  
  669. void rx_findnext( struct RexxHost *host, struct rxd_findnext **rxd, long action )
  670. {
  671.     struct rxd_findnext *rd = *rxd;
  672.     BOOL quiet=FALSE;
  673.     struct DisplayData *DD;
  674.  
  675.     if(( *rxd )->arg.id )
  676.     {
  677.         if( ValidDD( *( *rxd )->arg.id ))
  678.         {
  679.             DD = *( *rxd )->arg.id;
  680.         }
  681.         else
  682.         {
  683.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  684.             (*rxd)->rc = -RC_WARN;
  685.         }
  686.     }
  687.     else
  688.         DD = AktuDD;
  689.  
  690.     if( !(*rxd)->rc )
  691.     {
  692.     
  693.         if(rd->arg.quiet!=FALSE)quiet=TRUE;
  694.     
  695.         if(rd->arg.backwards!=FALSE)
  696.         {
  697.             if(!(SearchNext(BM_BACKWARD,quiet,FALSE,DD)))
  698.                 rd->rc=RC_WARN;
  699.         }
  700.         else
  701.         {
  702.             if(!SearchNext(0,quiet,FALSE,DD))
  703.                 rd->rc=RC_WARN;
  704.         }
  705.     }
  706. }
  707.  
  708. void rx_activate( struct RexxHost *host, struct rxd_activate **rxd, long action )
  709. {
  710.     mainflags |= MF_ICONIFY;
  711. }
  712.  
  713. void rx_deactivate( struct RexxHost *host, struct rxd_deactivate **rxd, long action )
  714. {
  715.     RemoveIconify();
  716. }
  717.  
  718. /****************************Attributes****************************/
  719.  
  720. #include "FileXARexxattribute.h"
  721.  
  722. BOOL IsNumeric(STRPTR String)
  723. {
  724.     while(*String && (*String == ' ' || *String == '\t'))
  725.         String++;
  726.  
  727.     if( *String == '-' ) String++;
  728.  
  729.     while(*String)
  730.     {
  731.         if(*String < '0' || *String > '9')
  732.             return(FALSE);
  733.         else
  734.             String++;
  735.     }
  736.  
  737.     return(TRUE);
  738. }
  739.  
  740. LONG FindAttrObject(UBYTE *Name)
  741. {
  742.     BOOL gefunden=FALSE;
  743.     LONG obnum=0;
  744.  
  745.     while((!gefunden) &&attributeobjects[obnum].name)
  746.     {
  747.         if(0==stricmp(attributeobjects[obnum].name,Name))
  748.             gefunden=TRUE;
  749.         else
  750.             obnum++;
  751.     }
  752.  
  753.     if(gefunden)return(obnum);
  754.     else return(-1);
  755. }
  756.  
  757. LONG FindFieldAttr(UBYTE *Name,LONG obnum)
  758. {
  759.     BOOL gefunden=FALSE;
  760.     LONG num=0;    
  761.  
  762.     while((attributeobjects[obnum].attr[num].name)&&(!gefunden))
  763.     {
  764.         if(stricmp(attributeobjects[obnum].attr[num].name,Name)==0)
  765.             gefunden=TRUE;
  766.         else
  767.             num++;
  768.     }
  769.  
  770.     if(gefunden)return(num);
  771.     else return(-1);
  772. }
  773.  
  774. void SetSingleAttr(struct rxd_setattr *rd,LONG obnum,LONG attrnum,UBYTE *String, APTR *id)
  775. {
  776.     LONG Number;
  777.     BOOL Boolean;
  778.  
  779.     switch(attributeobjects[obnum].attr[attrnum].typ)
  780.     {
  781.         case 1:
  782.             if(IsNumeric(String))
  783.             {
  784.                 Number=atol(String);
  785.             }
  786.             else
  787.             {
  788.                 rd->rc2=(LONG)GetStr( MSG_INFO_AREXX_VARHASTOBEANUMBER );
  789.                 rd->rc=-RC_ERROR;
  790.                 return;
  791.             }
  792.             break;
  793.         case 2:
  794.             while(*String && ((*String==' ')||(*String=='\t')))
  795.                 String++;
  796.  
  797.             if(0 == stricmp(String,"FALSE"))
  798.             {
  799.                 Boolean=FALSE;
  800.             }
  801.             else if(0 == stricmp(String,"TRUE"))
  802.             {
  803.                 Boolean=TRUE;
  804.             }
  805.             else
  806.             {
  807.                 rd->rc2=(LONG) GetStr( MSG_INFO_AREXX_VARHASTOBETRUEORFALSE );
  808.                 rd->rc=-RC_ERROR;
  809.                 return;
  810.             }
  811.             break;
  812.     }
  813.  
  814.     switch(obnum)
  815.     {
  816.         case APPLICATION_ATTRNUM:
  817.             switch(attrnum)
  818.             {
  819.                 case PRIORITY_APPATTR:
  820.                     if((Number>=-128)&&(Number<=127))SetTaskPri(FindTask(NULL), taskpri = Number);
  821.                     break;
  822.                 case SEARCHSTRING_APPATTR:
  823.                     SetSearchString(String);
  824.                     break;
  825.                 case REPLACESTRING_APPATTR:
  826.                     SetReplaceString(String);
  827.                     break;
  828.                 case STRINGSEARCH_APPATTR:
  829.                     if(Boolean)
  830.                         searchmode|=SM_STRING;
  831.                     else
  832.                         searchmode&=~SM_STRING;
  833.                     break;
  834.                 case CASESENSITIVSEARCH_APPATTR:
  835.                     if(Boolean)
  836.                         searchmode|=SM_CASE;
  837.                     else
  838.                         searchmode|=SM_CASE;
  839.                     break;
  840.                 case WILDSEARCH_APPATTR:
  841.                     if(Boolean)
  842.                         searchmode|=SM_WILDCARDS;
  843.                     else
  844.                         searchmode|=SM_WILDCARDS;
  845.                     break;
  846.                 case FILLSTRING_APPATTR:
  847.                     SetFillString( String );
  848.                     break;
  849.  
  850.                 case STRINGFILL_APPATTR:
  851.                     if(Boolean)
  852.                         SetFillMode( FM_STRING );
  853.                     else
  854.                         SetFillMode( FM_NUMBER );
  855.                     break;
  856.  
  857.                 case MAXUNDOMEMSIZE_APPATTR:
  858.                     SetMaxUndoMemSize(Number);
  859.                     break;
  860.                 case MAXUNDOLEVEL_APPATTR:
  861.                     SetUndoLevel(Number);
  862.                     break;
  863.                 case ALTJUMP_APPATTR:
  864.                     altsprungweite=Number;
  865.                     break;
  866.                 case SCROLLBORDER_APPATTR:
  867.                     SetScrollRand(Number);
  868.                     break;
  869.                 case CLIPBOARDUNIT_APPATTR:
  870.                     SetClipboardUnit(Number);
  871.                     break;
  872.                 case COMMANDSHELLWINDOW_APPATTR:
  873.                     SetCommandShellWindow(String);
  874.                     break;
  875.                 case COMMANDWINDOW_APPATTR:
  876.                     SetCommandWindow(String);
  877.                     break;
  878.                 case OVERWRITE_APPATTR:
  879.                     if(Boolean==TRUE)
  880.                         mainflags|=MF_OVERWRITE;
  881.                     else
  882.                         mainflags&=~MF_OVERWRITE;
  883.                     break;
  884.  
  885.                 case USEASL_APPATTR:
  886.                     SetRequester( Boolean );
  887.                     break;
  888.  
  889.                 default:
  890.                     rd->rc2=(LONG)GetStr( MSG_INFO_AREXX_FIELDISREADONLY );
  891.                     rd->rc=-RC_WARN;
  892.             }
  893.             break;
  894.  
  895.         case VIEW_ATTRNUM:
  896.             {
  897.                 struct DisplayData *DD;
  898.                 struct DisplayInhalt *DI;
  899.  
  900.                 if( id )
  901.                 {
  902.                     DI = (struct DisplayInhalt *)DisplayInhaltList.lh_Head;
  903.                 
  904.                     while( DI != ( struct DisplayInhalt * )&DisplayInhaltList.lh_Tail )
  905.                     {
  906.                         DD = (struct DisplayData *)DI->DisplayList.lh_Head;
  907.                 
  908.                         while( DD != ( struct DisplayData * )&DI->DisplayList.lh_Tail )
  909.                         {
  910.                             if( DD == *id )
  911.                                 break;
  912.  
  913.                             DD = ( struct DisplayData *)DD->Node.ln_Succ;
  914.                         }
  915.  
  916.                         if( DD == *id )
  917.                             break;
  918.                 
  919.                         DI = ( struct DisplayInhalt *)DI->Node.ln_Succ;
  920.                     }
  921.  
  922.                     if( *id != DD )
  923.                     {
  924.                         return;
  925.                     }
  926.                 }
  927.                 else
  928.                     DD = AktuDD;
  929.  
  930.                 switch(attrnum)
  931.                 {
  932.                     case DISPLAYTYP_VIEWATTR:
  933.                         SetDisplayTyp(Number, DD);
  934.                         break;
  935.  
  936.                     case DISPLAY_VIEWATTR:
  937.                         if(( Number > 0 ) && (Number <= 3 ))
  938.                         {
  939.                             if( DD->DisplayForm != Number )
  940.                             {
  941.                                 DD->DisplayForm = Number;
  942.                                 MakeDisplay( DD->DI );
  943.                             }
  944.                         }
  945.                         break;
  946.     
  947.                     case DISPLAYSPACES_VIEWATTR:
  948.                         if(( Number >= 0 ) && (Number <= 3 ))
  949.                         {
  950.                             if( Number == 3 ) Number = 8;
  951.     
  952.                             if(DD->DisplaySpaces != Number)
  953.                             {
  954.                                 DD->DisplaySpaces = Number;
  955.                                 MakeDisplay( DD->DI );
  956.                             }
  957.                         }                    
  958.                         break;
  959.     
  960.                     default:
  961.                         rd->rc2=(LONG)GetStr( MSG_INFO_AREXX_FIELDISREADONLY );
  962.                         rd->rc=-RC_WARN;
  963.                         break;
  964.                 }
  965.             }
  966.             break;
  967.  
  968.         case WINDOW_ATTRNUM:
  969.         case FILE_ATTRNUM:
  970.         case WINDOWS_ATTRNUM:
  971.         case FILES_ATTRNUM:
  972.             rd->rc2=(LONG)GetStr( MSG_INFO_AREXX_FIELDISREADONLY );
  973.             rd->rc=-RC_WARN;
  974.             break;
  975.     }
  976. }
  977.  
  978. void rx_setattr( struct RexxHost *host, struct rxd_setattr **rxd, long action)
  979. {
  980.     struct rxd_setattr *rd = *rxd;
  981.     STRPTR Result;
  982.     UBYTE VarName[160];
  983.     LONG obnum;    
  984.     LONG attrnum=0;
  985.  
  986.         /* OBJECT suchen */
  987.  
  988.     if(-1==(obnum=FindAttrObject(rd->arg.object)))
  989.     {
  990.         rd->rc2=(LONG) GetStr( MSG_INFO_AREXX_OBJECTNOTFOUND );
  991.         rd->rc=-RC_WARN;
  992.         return;
  993.     }
  994.  
  995.         /* FIELD falls vorhanden suchen */
  996.  
  997.     if(rd->arg.field)
  998.     {
  999.         if(-1==(attrnum=FindFieldAttr(rd->arg.field,obnum)))
  1000.         {
  1001.             rd->rc2=(LONG) GetStr( MSG_INFO_AREXX_FIELDNOTFOUND );
  1002.             rd->rc=-RC_WARN;
  1003.             return;
  1004.         }
  1005.     }
  1006.  
  1007.     rd->rc = 0;
  1008.  
  1009.     if(host->flags&ARB_HF_CMDSHELL)
  1010.     {
  1011.         if(rd->arg.fromstem)
  1012.         {
  1013.             rd->rc=-RC_WARN;
  1014.             rd->rc2=(LONG)GetStr( MSG_INFO_AREXX_FROMSTEMNOTPOSSIBLEINCOMMANDSHELL );
  1015.         }
  1016.         else
  1017.         {
  1018.             if(rd->arg.fromvar)
  1019.             {
  1020.                 SetSingleAttr(rd,obnum,attrnum,rd->arg.fromvar, rd->arg.id);
  1021.             }
  1022.             else
  1023.             {
  1024.                 rd->rc=-RC_WARN;
  1025.                 if(rd->arg.field)rd->rc2=(LONG)GetStr( MSG_INFO_AREXX_FROMVARREQUIRED );
  1026.                 else rd->rc2=(LONG)GetStr( MSG_INFO_AREXX_FROMVARANDFIELDREQUIRED );
  1027.             }
  1028.         }
  1029.     }
  1030.     else
  1031.     {
  1032.             /* Eine STEM Variable auslesen ? */
  1033.  
  1034.         if(rd->arg.fromstem)
  1035.         {
  1036.                 /* FIELD vorhanden, dann nur einen Wert setzen */
  1037.  
  1038.             if(rd->arg.field)
  1039.             {
  1040.                 sprintf(VarName,"%s.%s",rd->arg.fromstem,attributeobjects[obnum].attr[attrnum].name);
  1041.  
  1042.                 if(!GetRexxVar((struct Message *)host->akturexxmsg, VarName, &Result))
  1043.                     SetSingleAttr(rd,obnum,attrnum,Result, rd->arg.id);
  1044.                 else
  1045.                 {
  1046.                     rd->rc2= (LONG) GetStr( MSG_INFO_AREXX_CANTGETVAR );
  1047.                     rd->rc=-RC_ERROR;
  1048.                 }
  1049.             }
  1050.             else
  1051.             {
  1052.                 BOOL noerror=TRUE;
  1053.  
  1054.                 /* STEMVAR auslesen und alle Felder setzen */
  1055.  
  1056.                 while(noerror && attributeobjects[obnum].attr[attrnum].name)
  1057.                 {
  1058.                     sprintf(VarName,"%s.%s",rd->arg.fromstem,attributeobjects[obnum].attr[attrnum].name);
  1059.  
  1060.                     if(!GetRexxVar((struct Message *)host->akturexxmsg, VarName, &Result))
  1061.                     {
  1062.                         if(Result && strlen(Result))
  1063.                         {
  1064.                             SetSingleAttr(rd,obnum,attrnum,Result, rd->arg.id);
  1065.                             if(rd->rc<-RC_WARN)noerror=FALSE;
  1066.                         }
  1067.                     }
  1068.                     else
  1069.                     {
  1070.                         noerror=FALSE;
  1071.                         rd->rc2= (LONG) GetStr( MSG_INFO_AREXX_CANTGETVAR );
  1072.                         rd->rc=-RC_ERROR;
  1073.                     }
  1074.  
  1075.                     attrnum++;
  1076.                 }
  1077.             }
  1078.         }
  1079.         else
  1080.         if(rd->arg.fromvar)
  1081.         {
  1082.             if(rd->arg.field)
  1083.             {
  1084.                 SetSingleAttr(rd,obnum,attrnum,rd->arg.fromvar, rd->arg.id);
  1085.             }
  1086.             else
  1087.             {
  1088.                 rd->rc2=(LONG) GetStr( MSG_INFO_AREXX_FROMSTEMORFIELDREQUIRED );
  1089.                 rd->rc=-RC_WARN;
  1090.             }
  1091.         }
  1092.         else
  1093.         {
  1094.             rd->rc2=(LONG) GetStr( MSG_INFO_AREXX_FROMVARORFROMSTEMREQUIRED );
  1095.             rd->rc=-RC_WARN;
  1096.         }
  1097.     }
  1098. }
  1099.  
  1100. UBYTE *GetSingleAttr(struct rxd_getattr *rd,LONG obnum,LONG attrnum, APTR *id)
  1101. {
  1102.     static UBYTE Result[256];
  1103.     UBYTE *String;
  1104.     LONG Number;
  1105.     SHORT Boolean=FALSE;
  1106.  
  1107.     String = Result;
  1108.     *Result = 0;
  1109.  
  1110.     switch(obnum)
  1111.     {
  1112.         case APPLICATION_ATTRNUM:
  1113.             switch(attrnum)
  1114.             {
  1115.                 case SCREEN_APPATTR:
  1116.                     String = GetOwnScreenName();
  1117.                     break;
  1118.                 case VERSION_APPATTR:
  1119.                     String = VSTRING;
  1120.                     break;
  1121.                 case REGNAME_APPATTR:
  1122.                     if( regnum ) String = regname;
  1123.                     else String = "";
  1124.                     break;
  1125.                 case REGNUMBER_APPATTR:
  1126.                     Number = regnum;
  1127.                     break;
  1128.  
  1129.                 case AREXX_APPATTR:
  1130.                     String = MyRexxHost->portname;
  1131.                     break;
  1132.                 case PRIORITY_APPATTR:
  1133.                     Number = taskpri;
  1134.                     break;
  1135.                 case SEARCHSTRING_APPATTR:
  1136.                     String = GetAktuSearchString();
  1137.                     break;
  1138.                 case REPLACESTRING_APPATTR:
  1139.                     String = GetAktuReplaceString();
  1140.                     break;
  1141.                 case STRINGSEARCH_APPATTR:
  1142.                     Boolean = (searchmode&SM_STRING) ? TRUE : FALSE;
  1143.                     break;
  1144.                 case CASESENSITIVSEARCH_APPATTR:
  1145.                     Boolean = (searchmode&SM_CASE) ? TRUE : FALSE;
  1146.                     break;
  1147.                 case WILDSEARCH_APPATTR:
  1148.                     Boolean = (searchmode&SM_WILDCARDS) ? TRUE : FALSE;
  1149.                     break;
  1150.                 case FILLSTRING_APPATTR:
  1151.                     String = GetFillString();
  1152.                     break;
  1153.                 case STRINGFILL_APPATTR:
  1154.                     Boolean = (GetFillMode() & FM_STRING) ? TRUE : FALSE;
  1155.                     break;
  1156.                 case MAXUNDOMEMSIZE_APPATTR:
  1157.                     Number = maxundomemsize;
  1158.                     break;
  1159.                 case MAXUNDOLEVEL_APPATTR:
  1160.                     Number = UndoLevel;
  1161.                     break;
  1162.                 case ALTJUMP_APPATTR:
  1163.                     Number = altsprungweite;
  1164.                     break;
  1165.                 case SCROLLBORDER_APPATTR:
  1166.                     Number = realscrollrand;
  1167.                     break;
  1168.                 case CLIPBOARDUNIT_APPATTR:
  1169.                     Number = GetClipboardUnit();
  1170.                     break;
  1171.                 case COMMANDSHELLWINDOW_APPATTR:
  1172.                     String = arexxcommandshellwindow;
  1173.                     break;
  1174.                 case COMMANDWINDOW_APPATTR:
  1175.                     String = arexxcommandwindow;
  1176.                     break;
  1177.                 case OVERWRITE_APPATTR:
  1178.                     if(mainflags&MF_OVERWRITE)Boolean=TRUE;
  1179.                     break;
  1180.                 case USEASL_APPATTR:
  1181.                     Boolean = UseAsl;
  1182.                     break;
  1183.             }
  1184.             break;
  1185.  
  1186.         case WINDOW_ATTRNUM:
  1187.             {
  1188.                 struct DisplayInhalt *DI;
  1189.  
  1190.                 if( id )
  1191.                 {
  1192.                     DI = (struct DisplayInhalt *)DisplayInhaltList.lh_Head;
  1193.  
  1194.                     while( DI != ( struct DisplayInhalt * )&DisplayInhaltList.lh_Tail )
  1195.                     {
  1196.                         if( DI == *id )
  1197.                             break;
  1198.  
  1199.                         DI = ( struct DisplayInhalt *)DI->Node.ln_Succ;
  1200.                     }
  1201.  
  1202.                     if( DI != *id )
  1203.                     {
  1204.                         rd->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  1205.                         return( 0 );
  1206.                     }
  1207.                 }
  1208.                 else
  1209.                     DI = AktuDI;
  1210.  
  1211.                 switch(attrnum)
  1212.                 {
  1213.                     case LEFT_WNDATTR:
  1214.                         Number=DI->Wnd->LeftEdge;
  1215.                         break;
  1216.                     case TOP_WNDATTR:
  1217.                         Number=DI->Wnd->TopEdge;
  1218.                         break;
  1219.                     case WIDTH_WNDATTR:
  1220.                         Number=DI->Wnd->Width;
  1221.                         break;
  1222.                     case HEIGHT_WNDATTR:
  1223.                         Number=DI->Wnd->Height;
  1224.                         break;
  1225.                     case TITLE_WNDATTR:
  1226.                         String=DI->Wnd->Title;
  1227.                         break;
  1228.                     case MIN_WIDTH_WNDATTR:
  1229.                         Number=DI->Wnd->MinWidth;
  1230.                         break;
  1231.                     case MIN_HEIGHT_WNDATTR:
  1232.                         Number=DI->Wnd->MinHeight;
  1233.                         break;
  1234.                     case MAX_WIDTH_WNDATTR:
  1235.                         Number=DI->Wnd->MaxWidth;
  1236.                         break;
  1237.                     case MAX_HEIGHT_WNDATTR:
  1238.                         Number=DI->Wnd->MaxHeight;
  1239.                         break;
  1240.                     case VIEWCOUNT_WNDATTR:
  1241.                         {
  1242.                             struct DisplayData *DD;
  1243.                             int Anzahl = 0;
  1244.  
  1245.                             DD = (struct DisplayData *)DI->DisplayList.lh_Head;
  1246.  
  1247.                             while( DD != ( struct DisplayData * )&DI->DisplayList.lh_Tail )
  1248.                             {
  1249.                                 Anzahl++;
  1250.                                 DD = ( struct DisplayData *)DD->Node.ln_Succ;
  1251.                             }
  1252.                             
  1253.                             Number = Anzahl;
  1254.                         }
  1255.                         break;
  1256.                     case VIEWS_WNDATTR:
  1257.                         {
  1258.                             struct DisplayData *DD;
  1259.  
  1260.                             DD = (struct DisplayData *)DI->DisplayList.lh_Head;
  1261.  
  1262.                             while( DD != ( struct DisplayData * )&DI->DisplayList.lh_Tail )
  1263.                             {
  1264.                                 char Buffer[13];
  1265.                                 
  1266.                                 sprintf(Buffer,"%ld ", DD );
  1267.                                 strcat( Result, Buffer );
  1268.                                 DD = ( struct DisplayData *)DD->Node.ln_Succ;
  1269.                             }
  1270.                         }
  1271.                         break;
  1272.                 }
  1273.                 break;
  1274.             }
  1275.  
  1276.         case FILE_ATTRNUM:
  1277.             {
  1278.                 struct FileData *FD;
  1279.  
  1280.                 if( id )
  1281.                 {
  1282.                     FD = (struct FileData *)FileList.lh_Head;
  1283.                 
  1284.                     while( FD != ( struct FileData * )&FileList.lh_Tail )
  1285.                     {
  1286.                         if( FD == *id )
  1287.                             break;
  1288.                         FD = ( struct FileData *)FD->Node.ln_Succ;
  1289.                     }
  1290.                     
  1291.                     if( FD != *id )
  1292.                     {
  1293.                         rd->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  1294.                         return( 0 );
  1295.                     }
  1296.                 }
  1297.                 else
  1298.                     FD = AktuDD->FD;
  1299.  
  1300.                 switch( attrnum )
  1301.                 {
  1302.                     case FULLNAME_FILEATTR:
  1303.                         String = FD->Name;
  1304.                         break;
  1305.                     case PATH_FILEATTR:
  1306.                         strcpy( Result, FD->Name );
  1307.                         *PathPart( Result ) = 0;
  1308.                         String = Result;
  1309.                         break;
  1310.                     case NAME_FILEATTR:
  1311.                         String = FilePart( FD->Name);
  1312.                         break;
  1313.                     case CHANGES_FILEATTR:
  1314.                         Number = FD->FullChanges+FD->Changes+FD->RedoChanges;
  1315.                         break;
  1316.                     case FILELEN_FILEATTR:
  1317.                         Number = FD->Len;
  1318.                         break;
  1319.                     case MEMPOS_FILEATTR:
  1320.                         Number = ( ULONG )FD->Mem;
  1321.                         break;
  1322.                     case VIEWCOUNT_FILEATTR:
  1323.                         {
  1324.                             int Anzahl = 0;
  1325.                             struct DisplayData *DD;
  1326.  
  1327.                             DD = GetDDFromFD( FD->DisplayList.lh_Head );
  1328.  
  1329.                             while( DD != GetDDFromFD( &FD->DisplayList.lh_Tail ))
  1330.                             {
  1331.                                 Anzahl++;
  1332.                                 DD = GetDDFromFD( DD->FNode.ln_Succ );
  1333.                             }
  1334.                             
  1335.                             Number = Anzahl;
  1336.                         }
  1337.                         break;
  1338.                     case VIEWS_FILEATTR:
  1339.                         {
  1340.                             struct DisplayData *DD;
  1341.  
  1342.                             DD = GetDDFromFD( FD->DisplayList.lh_Head );
  1343.  
  1344.                             while( DD != GetDDFromFD( &FD->DisplayList.lh_Tail ))
  1345.                             {
  1346.                                 char Buffer[13];
  1347.                                 
  1348.                                 sprintf(Buffer,"%ld ", DD );
  1349.                                 strcat( Result, Buffer );
  1350.                                 DD = GetDDFromFD( DD->FNode.ln_Succ );
  1351.                             }
  1352.                         }
  1353.                         break;
  1354.                 }
  1355.             }
  1356.             break;
  1357.  
  1358.         case VIEW_ATTRNUM:
  1359.             {
  1360.                 struct DisplayData *DD;
  1361.                 struct DisplayInhalt *DI;
  1362.  
  1363.                 if( id )
  1364.                 {
  1365.                     DI = (struct DisplayInhalt *)DisplayInhaltList.lh_Head;
  1366.                 
  1367.                     while( DI != ( struct DisplayInhalt * )&DisplayInhaltList.lh_Tail )
  1368.                     {
  1369.                         DD = (struct DisplayData *)DI->DisplayList.lh_Head;
  1370.                 
  1371.                         while( DD != ( struct DisplayData * )&DI->DisplayList.lh_Tail )
  1372.                         {
  1373.                             if( DD == *id )
  1374.                                 break;
  1375.  
  1376.                             DD = ( struct DisplayData *)DD->Node.ln_Succ;
  1377.                         }
  1378.  
  1379.                         if( DD == *id )
  1380.                             break;
  1381.                 
  1382.                         DI = ( struct DisplayInhalt *)DI->Node.ln_Succ;
  1383.                     }
  1384.  
  1385.                     if( DD != *id )
  1386.                     {
  1387.                         rd->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  1388.                         return( 0 );
  1389.                     }
  1390.                 }
  1391.                 else DD = AktuDD;
  1392.  
  1393.                 switch( attrnum )
  1394.                 {
  1395.                     case LINES_VIEWATTR:
  1396.                         Number = DD->Zeilen;
  1397.                         break;
  1398.  
  1399.                     case BYTESPERLINE_VIEWATTR:
  1400.                         Number = DD->BPR;
  1401.                         break;
  1402.  
  1403.                     case CURSORPOS_VIEWATTR:
  1404.                         Number = DD->CPos;
  1405.                         break;
  1406.                     case MARKPOS_VIEWATTR:
  1407.                         Number = DD->MPos;
  1408.                         break;
  1409.                     case DISPLAYTYP_VIEWATTR:
  1410.                         Number = DD->DisplayTyp;
  1411.                         break;
  1412.                     case EDITASCII_VIEWATTR:
  1413.                         if(!(DD->Flags&DD_HEX))Boolean=TRUE;
  1414.                         break;
  1415.                     case MARK_VIEWATTR:
  1416.                         if(DD->Flags&DD_MARK)Boolean=TRUE;
  1417.                         break;
  1418.                     case DISPLAY_VIEWATTR:
  1419.                         Number = DD->DisplayForm;
  1420.                         break;
  1421.                     case DISPLAYSPACES_VIEWATTR:
  1422.                         if( DD->DisplaySpaces == 8 ) Number = 3;
  1423.                         else Number = DD->DisplaySpaces;
  1424.                         break;
  1425.                     case FILE_VIEWATTR:
  1426.                         Number = (LONG)DD->FD;
  1427.                         break;
  1428.                     case WINDOW_VIEWATTR:
  1429.                         Number = (LONG)DD->DI;
  1430.                         break;
  1431.                 }
  1432.             }
  1433.             break;
  1434.     }
  1435.  
  1436.     switch(attributeobjects[obnum].attr[attrnum].typ)
  1437.     {
  1438.         case 1:
  1439.             String=Result;
  1440.             sprintf(String,"%ld",Number);
  1441.             break;
  1442.         case 2:
  1443.             String=Result;
  1444.             strcpy(String,(Boolean==TRUE) ? "TRUE" : "FALSE");
  1445.             break;
  1446.     }
  1447.  
  1448.     return(String);        
  1449. }
  1450.  
  1451. LONG MySetRexxVar(struct RexxMsg *msg,char *name,char *value,ULONG len,BPTR fh)
  1452. {
  1453.     if( msg )
  1454.         return( SetRexxVar((struct Message *) msg, name, value, len ));
  1455.     else
  1456.     {
  1457.         if( name )
  1458.             FPrintf(fh, "%s = %s\n",name,value);
  1459.         else
  1460.             FPrintf(fh, "%s\n",value);
  1461.  
  1462.         return( 0 );
  1463.     }
  1464. }
  1465.  
  1466. void rx_getattr( struct RexxHost *host, struct rxd_getattr **rxd, long action )
  1467. {
  1468.     struct rxd_getattr *rd = *rxd;
  1469.     struct RexxMsg *msg;
  1470.     BPTR fh;
  1471.  
  1472.     LONG obnum;    
  1473.     LONG attrnum=0;
  1474.     UBYTE VarName[160];
  1475.     UBYTE *Value;
  1476.     LONG Result;
  1477.  
  1478.  
  1479.         /* OBJECT suchen */
  1480.  
  1481.     if(-1==(obnum=FindAttrObject(rd->arg.object)))
  1482.     {
  1483.         rd->rc2=(LONG) GetStr( MSG_INFO_AREXX_OBJECTNOTFOUND );
  1484.         rd->rc=-RC_WARN;
  1485.         return;
  1486.     }
  1487.  
  1488.         /* FIELD, falls vorhanden, suchen */
  1489.  
  1490.     if(rd->arg.field)
  1491.     {
  1492.         if(-1==(attrnum=FindFieldAttr(rd->arg.field,obnum)))
  1493.         {
  1494.             rd->rc2=(LONG) GetStr( MSG_INFO_AREXX_FIELDNOTFOUND );
  1495.             rd->rc=-RC_WARN;
  1496.             return;
  1497.         }
  1498.     }
  1499.  
  1500.     rd->rc = 0;
  1501.  
  1502.     if(host->flags&ARB_HF_CMDSHELL)
  1503.     {
  1504.         msg = 0;
  1505.         fh = host->outfh;
  1506.     }
  1507.     else
  1508.     {
  1509.         msg = host->akturexxmsg;
  1510.         fh = 0;
  1511.     }
  1512.  
  1513.     switch( obnum )
  1514.     {
  1515.         case WINDOWS_ATTRNUM:
  1516.         case FILES_ATTRNUM:
  1517.             {
  1518.                 struct Node *node, *endnode, *startnode;
  1519.                 int Anzahl = 0;
  1520.                 char Buffer[ 13 ];
  1521.         
  1522.                 switch( obnum )
  1523.                 {
  1524.                     case WINDOWS_ATTRNUM:
  1525.                         endnode = ( struct Node * )&DisplayInhaltList.lh_Tail;
  1526.                         startnode = DisplayInhaltList.lh_Head;
  1527.                         break;
  1528.                     case FILES_ATTRNUM:
  1529.                         endnode = ( struct Node * )&FileList.lh_Tail;
  1530.                         startnode = FileList.lh_Head;
  1531.                         break;
  1532.                 }
  1533.  
  1534.                 if( rd->arg.stem )
  1535.                 {
  1536.                     node = startnode;
  1537.         
  1538.                     while( node != endnode )
  1539.                     {
  1540.                         sprintf( VarName, "%s.%ld", rd->arg.stem, Anzahl );
  1541.                         sprintf( Buffer, "%ld", node );
  1542.         
  1543.                         if(Result = MySetRexxVar(msg,VarName,Buffer,strlen(Buffer),fh))
  1544.                         {
  1545.                             rd->rc = -RC_ERROR;
  1546.                             rd->rc2 = (LONG) GetStr( MSG_INFO_AREXX_CANTSETVAR );
  1547.                         }
  1548.         
  1549.                         Anzahl++;
  1550.                         node = node->ln_Succ;
  1551.                     }
  1552.         
  1553.                     sprintf( VarName, "%s.COUNT", rd->arg.stem, Anzahl );
  1554.                     sprintf( Buffer, "%ld", Anzahl );
  1555.         
  1556.                     if(Result = MySetRexxVar(msg,VarName,Buffer,strlen(Buffer),fh))
  1557.                     {
  1558.                         rd->rc = -RC_ERROR;
  1559.                         rd->rc2 = (LONG) GetStr( MSG_INFO_AREXX_CANTSETVAR );
  1560.                     }
  1561.                 }
  1562.                 else
  1563.                 {
  1564.                     LONG Gesamtlaenge=0;
  1565.         
  1566.                     node = startnode;
  1567.         
  1568.                     while( node != endnode )
  1569.                     {
  1570.                         sprintf( Buffer, "%ld",node );
  1571.                         Gesamtlaenge += 1 + strlen( Buffer );
  1572.         
  1573.                         Anzahl++;
  1574.                         node = node->ln_Succ;
  1575.                     }
  1576.         
  1577.                     sprintf( Buffer, "%ld", Anzahl );
  1578.                     Gesamtlaenge += 1 + strlen( Buffer );
  1579.         
  1580.                     if(Gesamtlaenge)
  1581.                     if(Value = AllocVec(Gesamtlaenge+1,MEMF_ANY|MEMF_CLEAR))
  1582.                     {
  1583.                         node = startnode;
  1584.         
  1585.                         while( node != endnode )
  1586.                         {
  1587.                             sprintf( Buffer, "%ld ",node );
  1588.                             strcat( Value, Buffer );
  1589.         
  1590.                             node = node->ln_Succ;
  1591.                         }
  1592.         
  1593.                         sprintf( Buffer, "%ld", Anzahl );
  1594.                         strcat( Value, Buffer );
  1595.         
  1596.                         if(Value)
  1597.                         {
  1598.                             if(rd->arg.var || (host->flags&ARB_HF_CMDSHELL))
  1599.                             {
  1600.                                 if(Result = MySetRexxVar(msg,rd->arg.var,Value,strlen(Value),fh))
  1601.                                 {
  1602.                                     rd->rc = -RC_ERROR;
  1603.                                     rd->rc2 = (LONG) GetStr( MSG_INFO_AREXX_CANTSETVAR );
  1604.                                 }
  1605.                             }
  1606.                             else                        
  1607.                             {
  1608.                                 host->userdata=1;
  1609.                                 ReplyRexxCommand(msg,0,0,Value);
  1610.                             }
  1611.         
  1612.                             FreeVec( Value );
  1613.                         }
  1614.                     }
  1615.                 }
  1616.             }
  1617.             break;
  1618.  
  1619.         default:
  1620.             if(rd->arg.stem)
  1621.             {
  1622.                 if(rd->arg.field)
  1623.                 {
  1624.                     sprintf(VarName,"%s.%s",rd->arg.stem,rd->arg.field);
  1625.         
  1626.                     Value=GetSingleAttr(rd,obnum,attrnum,rd->arg.id);
  1627.         
  1628.                     if(( !Value ) || (Result = MySetRexxVar(msg,VarName,Value,strlen(Value),fh)))
  1629.                     {
  1630.                         rd->rc = -RC_ERROR;
  1631.  
  1632.                         if( Value )
  1633.                             rd->rc2 = (LONG) GetStr( MSG_INFO_AREXX_CANTSETVAR );
  1634.                     }
  1635.                 }
  1636.                 else
  1637.                 {
  1638.                     BOOL noerror=TRUE;
  1639.         
  1640.                     while(noerror && attributeobjects[obnum].attr[attrnum].name)
  1641.                     {
  1642.                         sprintf(VarName,"%s.%s",rd->arg.stem,attributeobjects[obnum].attr[attrnum].name);
  1643.         
  1644.                         Value=GetSingleAttr(rd,obnum,attrnum,rd->arg.id);
  1645.         
  1646.                         if(( !Value ) || (Result = MySetRexxVar(msg,VarName,Value,strlen(Value),fh)))
  1647.                         {
  1648.                             noerror=FALSE;
  1649.                             rd->rc = -RC_ERROR;
  1650.                             if( Value )
  1651.                                 rd->rc2 = (LONG) GetStr( MSG_INFO_AREXX_CANTSETVAR );
  1652.                         }
  1653.         
  1654.                         attrnum++;
  1655.                     }
  1656.                 }
  1657.             }
  1658.             else
  1659.             {
  1660.                 if(rd->arg.field)
  1661.                 {
  1662.                     Value=GetSingleAttr(rd,obnum,attrnum,rd->arg.id);
  1663.                 }
  1664.                 else
  1665.                 {
  1666.                     LONG Gesamtlaenge=0, len;
  1667.         
  1668.                     while(attributeobjects[obnum].attr[attrnum].name)
  1669.                     {
  1670.                         char *str;
  1671.  
  1672.                         str = GetSingleAttr(rd,obnum,attrnum,rd->arg.id);
  1673.                         len = str ? strlen(str) : 0;
  1674.  
  1675.                         if( len )
  1676.                             Gesamtlaenge += 1 + len;
  1677.  
  1678.                         attrnum++;
  1679.                     }
  1680.         
  1681.                     attrnum=0;
  1682.                     Value = 0;
  1683.         
  1684.                     if(Gesamtlaenge)
  1685.                     if(Value = AllocVec(Gesamtlaenge+1,MEMF_ANY|MEMF_CLEAR))
  1686.                     {
  1687.                         while(attributeobjects[obnum].attr[attrnum].name)
  1688.                         {
  1689.                             char *str;
  1690.  
  1691.                             str = GetSingleAttr(rd,obnum,attrnum,rd->arg.id);
  1692.                             
  1693.                             if( str )
  1694.                             {
  1695.                                 strcat(Value,str);
  1696.                                 strcat(Value," ");
  1697.                             }
  1698.                             attrnum++;
  1699.                         }
  1700.         
  1701.                         Value[Gesamtlaenge-1]=0;
  1702.                     }
  1703.                 }
  1704.         
  1705.                 if(Value)
  1706.                 {
  1707.                     if(rd->arg.var || (host->flags&ARB_HF_CMDSHELL))
  1708.                     {
  1709.                         if(Result = MySetRexxVar(msg,rd->arg.var,Value,strlen(Value),fh))
  1710.                         {
  1711.                             rd->rc = -RC_ERROR;
  1712.                             rd->rc2 = (LONG) GetStr( MSG_INFO_AREXX_CANTSETVAR );
  1713.                         }
  1714.                     }
  1715.                     else                        
  1716.                     {
  1717.                         host->userdata=1;
  1718.                         ReplyRexxCommand(msg,0,0,Value);
  1719.                     }
  1720.                 }
  1721.                 else
  1722.                 {
  1723.                     rd->rc = -RC_ERROR;
  1724.  
  1725.                     if( Value )
  1726.                         rd->rc2 = (LONG) GetStr( MSG_INFO_AREXX_CANTSETVAR );
  1727.                 }
  1728.             }
  1729.             break;
  1730.     }
  1731. }
  1732.  
  1733. void rx_fault( struct RexxHost *host, struct rxd_fault **rxd, long action )
  1734. {
  1735.     struct rxd_fault *rd = *rxd;
  1736.  
  1737.     switch( action )
  1738.     {
  1739.         case RXIF_ACTION:
  1740.             if( rd->res.description = AllocVec(256,MEMF_ANY) )
  1741.             {
  1742.                 if( !Fault( *rd->arg.number, "",
  1743.                     rd->res.description, 256 ) )
  1744.                 {
  1745.                     rd->rc = -10;
  1746.                     rd->rc2 = (long) GetStr( MSG_INFO_AREXX_FAULTFAILED );
  1747.                 }
  1748.             }
  1749.             else
  1750.             {
  1751.                 rd->rc = 10;
  1752.                 rd->rc2 = ERROR_NO_FREE_STORE;
  1753.             }
  1754.             break;
  1755.         
  1756.         case RXIF_FREE:
  1757.             if(rd->res.description) FreeVec(rd->res.description);
  1758.             break;
  1759.     }
  1760. }
  1761.  
  1762. void rx_help( struct RexxHost *host, struct rxd_help **rxd, long action )
  1763. {
  1764.     struct rxd_help *rd = *rxd;
  1765.     struct rxs_command *rxc;
  1766.     int cnt = 1;
  1767.  
  1768.     switch( action )
  1769.     {
  1770.         case RXIF_ACTION:
  1771.             if( rd->arg.command )
  1772.             {
  1773.                 rxc = FindRXCommand( rd->arg.command );
  1774.                 if( !rxc )
  1775.                 {
  1776.                     rd->rc = -10;
  1777.                     rd->rc2 = (long) GetStr( MSG_INFO_AREXX_UNKNOWNCOMMAND );
  1778.                 }
  1779.                 else
  1780.                 {
  1781.                     if( rd->res.commanddesc = AllocVec( strlen(rxc->command)
  1782.                         + ((rxc->args) ? strlen(rxc->args):0)
  1783.                         + ((rxc->results) ? strlen(rxc->results):0) + 20, MEMF_ANY|MEMF_CLEAR))
  1784.                     {
  1785.                         sprintf( rd->res.commanddesc,
  1786.                             "%s%lc%s%s%s%s%s",
  1787.                             rxc->command, 
  1788.                             (rxc->results || rxc->args) ? ' ' : '\0',
  1789.                             rxc->results ? "VAR/K,STEM/K" : "",
  1790.                             (rxc->results && rxc->args) ? "," : "",
  1791.                             rxc->args ? rxc->args : "",
  1792.                             rxc->results ? " => " : "",
  1793.                             rxc->results ? rxc->results : "" );
  1794.                     }
  1795.                     else
  1796.                     {
  1797.                         rd->rc = 10;
  1798.                         rd->rc2 = ERROR_NO_FREE_STORE;
  1799.                     }
  1800.                 }
  1801.             }
  1802.             else
  1803.             {
  1804.                 char **s;
  1805.                 
  1806.                 rxc = rxs_commandlist;
  1807.                 while( rxc->command )
  1808.                 {
  1809.                     cnt++;
  1810.                     rxc++;
  1811.                 }
  1812.                 
  1813.                 if(!(s = AllocVec(4 * cnt, MEMF_ANY|MEMF_CLEAR)))
  1814.                 {
  1815.                     rd->rc = 10;
  1816.                     rd->rc2 = ERROR_NO_FREE_STORE;
  1817.                 }
  1818.                 else
  1819.                 {
  1820.                     rd->res.commandlist = s;
  1821.                     
  1822.                     rxc = rxs_commandlist;
  1823.                     while(rxc->command)
  1824.                     {
  1825.                         *s = rxc->command;
  1826.                         s++;
  1827.                         rxc++;
  1828.                     }
  1829.                 }
  1830.             }
  1831.             
  1832.             break;
  1833.         
  1834.         case RXIF_FREE:
  1835.             if(rd->res.commanddesc)    FreeVec(rd->res.commanddesc);
  1836.             if(rd->res.commandlist)    FreeVec(rd->res.commandlist);
  1837.             break;
  1838.     }
  1839. }
  1840.  
  1841. void rx_rx( struct RexxHost *host, struct rxd_rx **rxd, long action )
  1842. {
  1843.     struct {
  1844.         struct rxd_rx rd;
  1845.         long rc;
  1846.     } *rd = (void *) *rxd;
  1847.     
  1848.     BPTR fh = NULL;
  1849.     struct RexxMsg *sentrm;
  1850.  
  1851.     switch( action )
  1852.     {
  1853.         case RXIF_INIT:
  1854.             *rxd = AllocVec(sizeof *rd, MEMF_ANY);
  1855.             break;
  1856.             
  1857.         case RXIF_ACTION:
  1858.             /* Kommando leer? */
  1859.             if( !rd->rd.arg.command )
  1860.                 return;
  1861.             
  1862.             /* Mit Ein-/Ausgabe-Fenster? */
  1863.             if( rd->rd.arg.console )
  1864.             {
  1865.                 fh = Open(arexxcommandwindow, MODE_NEWFILE );
  1866.                 if( !fh )
  1867.                 {
  1868.                     rd->rd.rc = -20;
  1869.                     rd->rd.rc2 = (long) GetStr( MSG_INFO_AREXX_RXCANTOPENWINDOW );
  1870.                     return;
  1871.                 }
  1872.             }
  1873.             
  1874.             /* Kommando abschicken */
  1875.             if( !(sentrm = SendRexxCommand(host, rd->rd.arg.command, fh)) )
  1876.             {
  1877.                 rd->rd.rc = -20;
  1878.                 rd->rd.rc2 = (long) GetStr( MSG_INFO_AREXX_RXCANTSENDAREXXCOMMAND );
  1879.                 return;
  1880.             }
  1881.             
  1882.             /* auf den Reply warten */
  1883.             if( !rd->rd.arg.async )
  1884.             {
  1885.                 struct RexxMsg *rm;
  1886.                 BOOL waiting = TRUE;
  1887.                 
  1888.                 do
  1889.                 {
  1890.                     WaitPort( host->port );
  1891.                     
  1892.                     while( rm = (struct RexxMsg *) GetMsg(host->port) )
  1893.                     {
  1894.                         /* Reply? */
  1895.                         if( rm->rm_Node.mn_Node.ln_Type == NT_REPLYMSG )
  1896.                         {
  1897.                             /* 'unsere' Msg? */
  1898.                             if( rm == sentrm )
  1899.                             {
  1900.                                 rd->rc = rm->rm_Result1;
  1901.                                 rd->rd.res.rc = &rd->rc;
  1902.                                 
  1903.                                 if( !rm->rm_Result1 && rm->rm_Result2 )
  1904.                                 {
  1905.                                     /* Res2 ist String */
  1906.                                     rd->rd.res.result =
  1907.                                         strdup( (char *) rm->rm_Result2 );
  1908.                                 }
  1909.                                 
  1910.                                 waiting = FALSE;
  1911.                             }
  1912.                             
  1913.                             FreeRexxCommand( rm );
  1914.                             --host->replies;
  1915.                         }
  1916.                         
  1917.                         /* sonst Kommando -> Fehler */
  1918.                         else if( ARG0(rm) )
  1919.                         {
  1920.                             ReplyRexxCommand( rm, -20, (long)
  1921.                                 "CommandShell Port", NULL );
  1922.                         }
  1923.                     }
  1924.                 }
  1925.                 while( waiting );
  1926.             }
  1927.             
  1928.             break;
  1929.         
  1930.         case RXIF_FREE:
  1931.             if( rd->rd.res.result ) FreeVec( rd->rd.res.result );
  1932.             free( rd );
  1933.             break;
  1934.     }
  1935. }
  1936.  
  1937. void rx_font( struct RexxHost *host, struct rxd_font **rxd, long action )
  1938. {
  1939.     struct rxd_font *rd = *rxd;
  1940.  
  1941.     if(rd->arg.name&&rd->arg.size)
  1942.     {
  1943.         if(( *rxd )->arg.id )
  1944.         {
  1945.             if( ValidDI( *( *rxd )->arg.id ))
  1946.             {
  1947.                 MySetFontNameSize(rd->arg.name,*rd->arg.size,*( *rxd )->arg.id);
  1948.             }
  1949.             else
  1950.             {
  1951.                 (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  1952.                 (*rxd)->rc = -RC_WARN;
  1953.             }
  1954.         }
  1955.         else
  1956.             MySetFontNameSize(rd->arg.name,*rd->arg.size,AktuDI);
  1957.     }
  1958. }
  1959.  
  1960. void rx_multiundofunction( BOOL Un, struct rxd_redo **rxd )
  1961. {
  1962.     struct FileData *FD;
  1963.  
  1964.     if(( *rxd )->arg.id )
  1965.     {
  1966.         if( ValidFD( *( *rxd )->arg.id ))
  1967.         {
  1968.             FD = *( *rxd )->arg.id;
  1969.         }
  1970.         else
  1971.         {
  1972.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  1973.             (*rxd)->rc = -RC_WARN;
  1974.         }
  1975.     }
  1976.     else
  1977.         FD = AktuDD->FD;
  1978.  
  1979.     if( !(*rxd)->rc )
  1980.     {
  1981.         struct rxd_redo *rd = *rxd;
  1982.         long k, i = 1;
  1983.     
  1984.         if( rd->arg.number )
  1985.             i = *rd->arg.number;
  1986.     
  1987.         for( k = 0; k < i; k++ )
  1988.         {
  1989.             if( Un )
  1990.             {
  1991.                 if( !Undo( FD ))
  1992.                     break;
  1993.             }
  1994.             else
  1995.             {
  1996.                 if( !Redo( FD ))
  1997.                     break;
  1998.             }
  1999.         }
  2000.     }
  2001. }
  2002.  
  2003. void rx_redo( struct RexxHost *host, struct rxd_redo **rxd, long action )
  2004. {
  2005.     rx_multiundofunction( FALSE, rxd );
  2006. }
  2007.  
  2008. void rx_undo( struct RexxHost *host, struct rxd_undo **rxd, long action )
  2009. {
  2010.     rx_multiundofunction( TRUE, rxd );
  2011. }
  2012.  
  2013. void rx_activatewindow( struct RexxHost *host, struct rxd_activatewindow **rxd, long action )
  2014. {
  2015.     if(( *rxd )->arg.id )
  2016.     {
  2017.         if( ValidDI( *( *rxd )->arg.id ))
  2018.         {
  2019.             MyActivateWindow( *( *rxd )->arg.id );
  2020.             ActivateWindow( AktuDI->Wnd );
  2021.         }
  2022.         else
  2023.         {
  2024.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2025.             (*rxd)->rc = -RC_WARN;
  2026.         }
  2027.     }
  2028.     else
  2029.         ActivateWindow( AktuDI->Wnd );
  2030. }
  2031.  
  2032. void rx_activateview( struct RexxHost *host, struct rxd_activateview **rxd, long action )
  2033. {
  2034.     if(( *rxd )->arg.id )
  2035.     {
  2036.         if( ValidDD( *( *rxd )->arg.id ))
  2037.         {
  2038.             struct DisplayData *DD;
  2039.  
  2040.             DD = (struct DisplayData *)*( *rxd )->arg.id;
  2041.  
  2042.             if( DD->DI != AktuDI )
  2043.             {
  2044.                 MyActivateWindow( DD->DI );
  2045.                 ActivateWindow( DD->DI->Wnd );
  2046.             }
  2047.  
  2048.             ChangeAktuView( DD );
  2049.         }
  2050.         else
  2051.         {
  2052.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2053.             (*rxd)->rc = -RC_WARN;
  2054.         }
  2055.     }
  2056. }
  2057.  
  2058. void rx_adjustwindowsize( struct RexxHost *host, struct rxd_activatewindow **rxd, long action )
  2059. {
  2060.     if(( *rxd )->arg.id )
  2061.     {
  2062.         if( ValidDI( *( *rxd )->arg.id ))
  2063.         {
  2064.             AdjustWindowSize( *( *rxd )->arg.id );
  2065.         }
  2066.         else
  2067.         {
  2068.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2069.             (*rxd)->rc = -RC_WARN;
  2070.         }
  2071.     }
  2072.     else
  2073.         AdjustWindowSize( AktuDI );
  2074. }
  2075.  
  2076. void rx_changewindow( struct RexxHost *host, struct rxd_changewindow **rxd, long action )
  2077. {
  2078.     struct Window *Wnd;
  2079.  
  2080.     if(( *rxd )->arg.id )
  2081.     {
  2082.         if( ValidDI( *( *rxd )->arg.id ))
  2083.         {
  2084.             Wnd = ((struct DisplayInhalt *)*( *rxd )->arg.id)->Wnd;
  2085.         }
  2086.         else
  2087.         {
  2088.             Wnd = NULL;
  2089.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2090.             (*rxd)->rc = -RC_WARN;
  2091.         }
  2092.     }
  2093.     else
  2094.         Wnd = AktuDI->Wnd;
  2095.  
  2096.     if( Wnd ) 
  2097.     {
  2098.         WORD Left, Top, Width, Height;
  2099.  
  2100.         if(( *rxd )->arg.leftedge )
  2101.             Left = *( *rxd )->arg.leftedge;
  2102.         else
  2103.             Left = Wnd->LeftEdge;
  2104.  
  2105.         if(( *rxd)->arg.topedge )
  2106.             Top = *( *rxd )->arg.topedge;
  2107.         else
  2108.             Top = Wnd->TopEdge;
  2109.  
  2110.         if(( *rxd )->arg.width )
  2111.             Width = *( *rxd )->arg.width;
  2112.         else
  2113.             Width = Wnd->Width;
  2114.  
  2115.         if(( *rxd )->arg.height )
  2116.             Height = *( *rxd )->arg.height;
  2117.         else
  2118.             Height = Wnd->Height;
  2119.  
  2120.         ChangeWindowBox(Wnd,Left,Top,Width,Height);
  2121.     }
  2122. }
  2123.  
  2124. void rx_movewindow( struct RexxHost *host, struct rxd_movewindow **rxd, long action )
  2125. {
  2126.     struct rxd_movewindow *rd = *rxd;
  2127.     struct Window *Wnd;
  2128.  
  2129.     if(( *rxd )->arg.id )
  2130.     {
  2131.         if( ValidDI( *( *rxd )->arg.id ))
  2132.         {
  2133.             Wnd = ((struct DisplayInhalt *)*( *rxd )->arg.id)->Wnd;
  2134.         }
  2135.         else
  2136.         {
  2137.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2138.             (*rxd)->rc = -RC_WARN;
  2139.         }
  2140.     }
  2141.     else
  2142.         Wnd = AktuDI->Wnd;
  2143.  
  2144.     if( !(*rxd)->rc )
  2145.     {
  2146.         long leftedge = -1, topedge = -1;
  2147.  
  2148.         if( rd->arg.leftedge )
  2149.             leftedge = *rd->arg.leftedge;
  2150.  
  2151.         if( rd->arg.topedge )
  2152.             topedge = *rd->arg.topedge;
  2153.  
  2154.         if(leftedge==-1)leftedge=Wnd->LeftEdge;
  2155.         if(topedge==-1)topedge=Wnd->TopEdge;
  2156.  
  2157.         ChangeWindowBox(Wnd,leftedge,topedge,Wnd->Width,Wnd->Height);
  2158.     }
  2159. }
  2160.  
  2161. void rx_sizewindow( struct RexxHost *host, struct rxd_sizewindow **rxd, long action )
  2162. {
  2163.     struct rxd_sizewindow *rd = *rxd;
  2164.     long height, width;
  2165.     struct Window *Wnd;
  2166.  
  2167.     if(( *rxd )->arg.id )
  2168.     {
  2169.         if( ValidDI( *( *rxd )->arg.id ))
  2170.         {
  2171.             Wnd = ((struct DisplayInhalt *)*( *rxd )->arg.id)->Wnd;
  2172.         }
  2173.         else
  2174.         {
  2175.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2176.             (*rxd)->rc = -RC_WARN;
  2177.         }
  2178.     }
  2179.     else
  2180.         Wnd = AktuDI->Wnd;
  2181.  
  2182.  
  2183.     if( !(*rxd)->rc )
  2184.     {
  2185.         height=*rd->arg.height;
  2186.         width=*rd->arg.width;
  2187.  
  2188.         if(height==-1)height=Wnd->Height;
  2189.         if(width==-1)width=Wnd->Width;
  2190.  
  2191.         ChangeWindowBox(Wnd,Wnd->LeftEdge,Wnd->TopEdge,width,height);
  2192.     }
  2193. }
  2194.  
  2195. void rx_multiwindowfunction( WORD Typ, struct rxd_windowtoback **rxd )
  2196. {
  2197.     struct Window *Wnd;
  2198.  
  2199.     if(( *rxd )->arg.id )
  2200.     {
  2201.         if( ValidDI( *( *rxd )->arg.id ))
  2202.         {
  2203.             Wnd = ((struct DisplayInhalt *)*( *rxd )->arg.id)->Wnd;
  2204.         }
  2205.         else
  2206.         {
  2207.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2208.             (*rxd)->rc = -RC_WARN;
  2209.         }
  2210.     }
  2211.     else
  2212.         Wnd = AktuDI->Wnd;
  2213.  
  2214.     if( !(*rxd)->rc )
  2215.     {
  2216.         switch( Typ )
  2217.         {
  2218.             case 0:
  2219.                 ZipWindow(Wnd);
  2220.                 break;
  2221.             case 1:
  2222.                 WindowToFront(Wnd);
  2223.                 break;
  2224.             case 2:
  2225.                 WindowToBack(Wnd);
  2226.                 break;
  2227.         }
  2228.     }
  2229. }
  2230. void rx_zipwindow( struct RexxHost *host, struct rxd_zipwindow **rxd, long action )
  2231. {
  2232.     rx_multiwindowfunction( 0, rxd );
  2233. }
  2234.  
  2235. void rx_windowtofront( struct RexxHost *host, struct rxd_windowtofront **rxd, long action )
  2236. {
  2237.     rx_multiwindowfunction( 1, rxd );
  2238. }
  2239.  
  2240. void rx_windowtoback( struct RexxHost *host, struct rxd_windowtoback **rxd, long action )
  2241. {
  2242.     rx_multiwindowfunction( 2, rxd );
  2243. }
  2244.  
  2245. void rx_requestfile( struct RexxHost *host, struct rxd_requestfile **rxd, long action )
  2246. {
  2247.     struct rxd_requestfile *rd = *rxd;
  2248.  
  2249.     switch( action )
  2250.     {
  2251.         case RXIF_INIT:
  2252.             rd->res.filename = AllocVec(256,MEMF_CLEAR);
  2253.             break;
  2254.             
  2255.         case RXIF_ACTION:
  2256.             if( rd->arg.path ) strcpy( rd->res.filename, rd->arg.path );
  2257.             if( rd->arg.file ) AddPart( rd->res.filename, rd->arg.file, 256 );
  2258.  
  2259.             if( MyRequestFile( rd->res.filename, rd->arg.title ? rd->arg.title : 0, rd->arg.pattern ? rd->arg.pattern : 0, FALSE ))
  2260.                 rd->rc = 0;
  2261.             else
  2262.                 rd->rc=RC_WARN;    
  2263.             break;
  2264.         
  2265.         case RXIF_FREE:
  2266.             FreeVec(rd->res.filename);
  2267.             break;
  2268.     }
  2269. }
  2270.  
  2271. void rx_grabmemory( struct RexxHost *host, struct rxd_grabmemory **rxd, long action )
  2272. {
  2273.     struct rxd_grabmemory *rd = *rxd;
  2274.     struct DisplayData *DD;
  2275.  
  2276.     if(( *rxd )->arg.id )
  2277.     {
  2278.         if( ValidDD( *( *rxd )->arg.id ))
  2279.         {
  2280.             DD = *( *rxd )->arg.id;
  2281.         }
  2282.         else
  2283.         {
  2284.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2285.             (*rxd)->rc = -RC_WARN;
  2286.         }
  2287.     }
  2288.     else
  2289.         DD = AktuDD;
  2290.  
  2291.     if( !(*rxd)->rc )
  2292.     {
  2293.         if((rd->arg.start)&&(rd->arg.end))
  2294.         {
  2295.             if(( rd->arg.force != FALSE ) || ( QuitView( 4, DD )))
  2296.                 GrabMemory( *rd->arg.start, *rd->arg.end, DD );
  2297.             else
  2298.                 rd->rc = RC_WARN;
  2299.         }
  2300.     }
  2301. }
  2302.  
  2303. void rx_printblock( struct RexxHost *host, struct rxd_printblock **rxd, long action )
  2304. {
  2305.     PrintBlock();
  2306. }
  2307.  
  2308. void rx_multiddfunction( WORD Typ, struct rxd_cut **rxd )
  2309. {
  2310.     struct DisplayData *DD;
  2311.  
  2312.     if(( *rxd )->arg.id )
  2313.     {
  2314.         if( ValidDD( *( *rxd )->arg.id ))
  2315.         {
  2316.             DD = *( *rxd )->arg.id;
  2317.         }
  2318.         else
  2319.         {
  2320.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2321.             (*rxd)->rc = -RC_WARN;
  2322.         }
  2323.     }
  2324.     else
  2325.         DD = AktuDD;
  2326.  
  2327.  
  2328.     if( !(*rxd)->rc )
  2329.         switch( Typ )
  2330.         {
  2331.             case 0:
  2332.                 if( !( DD->FD->Typ == FD_GRAB ))
  2333.                     AppendBlock( DD );
  2334.                 break;
  2335.  
  2336.             case 1:
  2337.                 Copy( DD );
  2338.                 break;
  2339.  
  2340.             case 2:
  2341.                 Cut( DD );
  2342.                 break;
  2343.  
  2344.             case 3:
  2345.                 FillDD( DD );
  2346.                 break;
  2347.  
  2348.             case 4:
  2349.                 if( !( DD->FD->Typ == FD_GRAB ))
  2350.                     InsertBlock( DD );
  2351.                 break;
  2352.  
  2353.             case 5:
  2354.                 Paste( DD );
  2355.                 break;
  2356.  
  2357.             case 6:
  2358.                 Mark( DD );
  2359.                 break;
  2360.  
  2361.             case 7:
  2362.                 MakeDisplayMax( DD );
  2363.                 break;
  2364.  
  2365.             case 8:
  2366.                 MakeDisplayBigger( DD );
  2367.                 break;
  2368.  
  2369.             case 9:
  2370.                 MakeDisplaySmaller( DD );
  2371.                 break;
  2372.         }
  2373. }
  2374.  
  2375. void rx_setblockmark( struct RexxHost *host, struct rxd_setblockmark **rxd, long action )
  2376. {
  2377.     rx_multiddfunction( 6, rxd );
  2378. }
  2379.  
  2380. void rx_cut( struct RexxHost *host, struct rxd_cut **rxd, long action )
  2381. {
  2382.     rx_multiddfunction( 2, rxd );
  2383. }
  2384.  
  2385. void rx_copy( struct RexxHost *host, struct rxd_copy **rxd, long action )
  2386. {
  2387.     rx_multiddfunction( 1, rxd );
  2388. }
  2389.  
  2390. void rx_fill( struct RexxHost *host, struct rxd_fill **rxd, long action )
  2391. {
  2392.     rx_multiddfunction( 3, rxd );
  2393. }
  2394.  
  2395. void rx_paste( struct RexxHost *host, struct rxd_paste **rxd, long action )
  2396. {
  2397.     rx_multiddfunction( 5, rxd );
  2398. }
  2399.  
  2400. void rx_insert( struct RexxHost *host, struct rxd_insert **rxd, long action )
  2401. {
  2402.     rx_multiddfunction( 4, rxd );
  2403. }
  2404.  
  2405. void rx_append( struct RexxHost *host, struct rxd_append **rxd, long action )
  2406. {
  2407.     rx_multiddfunction( 0, rxd );
  2408. }
  2409.  
  2410. void rx_expandview( struct RexxHost *host, struct rxd_expandview **rxd, long action )
  2411. {
  2412.     rx_multiddfunction( 7, rxd );
  2413. }
  2414.  
  2415. void rx_growview( struct RexxHost *host, struct rxd_growview **rxd, long action )
  2416. {
  2417.     rx_multiddfunction( 8, rxd );
  2418. }
  2419.  
  2420. void rx_shrinkview( struct RexxHost *host, struct rxd_shrinkview **rxd, long action )
  2421. {
  2422.     rx_multiddfunction( 9, rxd );
  2423. }
  2424.  
  2425.  
  2426. void rx_loadblock( struct RexxHost *host, struct rxd_loadblock **rxd, long action )
  2427. {
  2428.     struct rxd_loadblock *rd = *rxd;
  2429.  
  2430.     if( rd->arg.name )
  2431.     {
  2432.         if( !LoadBlock( rd->arg.name ))
  2433.             rd->rc = RC_WARN;
  2434.     }
  2435.     else
  2436.         if( !LoadBlockFR())
  2437.             rd->rc = RC_WARN;
  2438. }
  2439.  
  2440. void rx_saveblock( struct RexxHost *host, struct rxd_saveblock **rxd, long action )
  2441. {
  2442.     struct rxd_saveblock *rd = *rxd;
  2443.  
  2444.     if( rd->arg.name )
  2445.     {
  2446.         if( !SaveBlock( rd->arg.name ))
  2447.             rd->rc = RC_WARN;
  2448.     }
  2449.     else
  2450.         if( !SaveBlockFR())
  2451.             rd->rc = RC_WARN;
  2452. }
  2453.  
  2454. void rx_loadsettings( struct RexxHost *host, struct rxd_loadsettings **rxd, long action )
  2455. {
  2456.     struct rxd_loadsettings *rd = *rxd;
  2457.  
  2458.     if( rd->arg.name )
  2459.     {
  2460.         if(!LoadSettings(rd->arg.name,FALSE))rd->rc=RC_WARN;
  2461.     }
  2462.     else
  2463.     {    
  2464.         if(!LoadSettingsFR())rd->rc=RC_WARN;
  2465.     }
  2466. }
  2467.  
  2468. void rx_savesettings( struct RexxHost *host, struct rxd_savesettings **rxd, long action )
  2469. {
  2470.     SaveSettingsDefault();
  2471. }
  2472.  
  2473. void rx_savesettingsas( struct RexxHost *host, struct rxd_savesettingsas **rxd, long action )
  2474. {
  2475.     struct rxd_savesettingsas *rd = *rxd;
  2476.  
  2477.     if(rd->arg.name)
  2478.     {
  2479.         if(!SaveSettings(rd->arg.name,FALSE))rd->rc=RC_WARN;
  2480.     }
  2481.     else
  2482.     {
  2483.         if(!SaveSettingsFR())rd->rc=RC_WARN;
  2484.     }
  2485. }
  2486.  
  2487. void rx_loaddisplaytyp( struct RexxHost *host, struct rxd_loaddisplaytyp **rxd, long action )
  2488. {
  2489.     struct rxd_loaddisplaytyp *rd = *rxd;
  2490.  
  2491.     if(rd->arg.name)
  2492.     {
  2493.         if(!LoadUserDisplaytyp(rd->arg.name))rd->rc=RC_WARN;
  2494.     }
  2495.     else
  2496.         if(!LoadUserDisplaytypFR())rd->rc=RC_WARN;
  2497. }
  2498.  
  2499. void rx_assigncommand( struct RexxHost *host, struct rxd_assigncommand **rxd, long action )
  2500. {
  2501.     struct rxd_assigncommand *rd = *rxd;
  2502.  
  2503.     if(rd->arg.number)
  2504.     {
  2505.         SetARexxCommand(*rd->arg.number,rd->arg.name);
  2506.     }
  2507.     else
  2508.     {
  2509.         SetARexxCommand(-1,rd->arg.name);
  2510.     }
  2511. }
  2512.  
  2513. void rx_executecommand( struct RexxHost *host, struct rxd_executecommand **rxd, long action )
  2514. {
  2515.     struct rxd_executecommand *rd = *rxd;
  2516.  
  2517.     if(rd->arg.number)
  2518.     {
  2519.         ExecuteARexxCommandNumber(*rd->arg.number);
  2520.     }
  2521.     else
  2522.     if(rd->arg.name)
  2523.     {
  2524.         ExecuteARexxCommand(rd->arg.name);
  2525.     }
  2526. }
  2527.  
  2528. void rx_loadcommands( struct RexxHost *host, struct rxd_loadcommands **rxd, long action )
  2529. {
  2530.     struct rxd_loadcommands *rd = *rxd;
  2531.  
  2532.     if(rd->arg.name)
  2533.     {
  2534.         if(!LoadARexxCommands(rd->arg.name))rd->rc=RC_WARN;
  2535.     }
  2536.     else
  2537.         if(!LoadARexxCommandsFR())rd->rc=RC_WARN;
  2538. }
  2539.  
  2540. void rx_savecommands( struct RexxHost *host, struct rxd_savecommands **rxd, long action )
  2541. {
  2542.     SaveARexxCommandsDefault();
  2543. }
  2544.  
  2545. void rx_savecommandsas( struct RexxHost *host, struct rxd_savecommandsas **rxd, long action )
  2546. {
  2547.     struct rxd_savecommandsas *rd = *rxd;
  2548.  
  2549.     if(rd->arg.name)
  2550.     {
  2551.         if(!SaveARexxCommands(rd->arg.name))rd->rc=RC_WARN;
  2552.     }
  2553.     else
  2554.         if(!SaveARexxCommandsFR())rd->rc=RC_WARN;
  2555. }
  2556.  
  2557. void rx_setscreen( struct RexxHost *host, struct rxd_setscreen **rxd, long action )
  2558. {
  2559.     struct rxd_setscreen *rd = *rxd;
  2560.  
  2561.     if( rd->arg.own )
  2562.     {
  2563.         SetScreenOwnPublic();
  2564.     }
  2565.     else if(rd->arg.name)
  2566.     {
  2567.         SetScreenTypePublic( rd->arg.name );
  2568.     }
  2569. }
  2570.  
  2571. void rx_getblock( struct RexxHost *host, struct rxd_getblock **rxd, long action )
  2572. {
  2573.     struct rxd_getblock *rd = *rxd;
  2574.  
  2575.     switch( action )
  2576.     {
  2577.         case RXIF_ACTION:
  2578.             {
  2579.                 UBYTE *blockmem;
  2580.                 ULONG blocklaenge;
  2581.  
  2582.                 if( blockmem = GetClip( &blocklaenge ))
  2583.                 {
  2584.                     if(blocklaenge<32767)
  2585.                     {
  2586.                         if(rd->res.block = AllocVec(blocklaenge*2+1,MEMF_ANY))
  2587.                         {
  2588.                             UBYTE *mem=rd->res.block,*bmem=blockmem;
  2589.                             long k;
  2590.                             
  2591.                             for(k=0;k<blocklaenge;k++)
  2592.                             {
  2593.                                 *mem++=hexarray[*bmem >>  4];
  2594.                                 *mem++=hexarray[*bmem++ &  0xf];
  2595.                             }
  2596.                             *mem=0;
  2597.                         }
  2598.                     }
  2599.                     else
  2600.                     {
  2601.                         rd->rc=-RC_WARN;
  2602.                         rd->rc2=(LONG) GetStr( MSG_INFO_AREXX_BLOCKTOOLONG );
  2603.                     }
  2604.  
  2605.                     FreeMem( blockmem, blocklaenge );
  2606.                 }
  2607.                 else
  2608.                 {
  2609.                     rd->rc=-RC_WARN;
  2610.                     rd->rc2=(LONG) GetStr( MSG_INFO_GLOBAL_BUFFEREMPTY );
  2611.                 }
  2612.             }
  2613.             break;
  2614.         
  2615.         case RXIF_FREE:
  2616.             if(rd->res.block)FreeVec(rd->res.block);
  2617.             break;
  2618.     }
  2619. }
  2620.  
  2621. void rx_setblock( struct RexxHost *host, struct rxd_setblock **rxd, long action )
  2622. {
  2623.     struct rxd_setblock *rd = *rxd;
  2624.     UBYTE *ptr;
  2625.     long anz=0;
  2626.  
  2627.     ptr=rd->arg.block;
  2628.  
  2629.     while(*ptr){if(isxdigit(*ptr))anz++;ptr++;}
  2630.     
  2631.     if(ptr = AllocVec(anz/2,MEMF_ANY))
  2632.     {
  2633.         if(StringToMem(rd->arg.block, ptr, anz/2))
  2634.         {
  2635.             SaveClip(ptr,anz/2);
  2636.         }
  2637.         else
  2638.         {
  2639.             rd->rc=-RC_WARN;
  2640.             rd->rc2= (LONG) GetStr( MSG_INFO_AREXX_BLOCKCONTAINSILLEGALCHARACTERS );
  2641.         }
  2642.         FreeVec( ptr );
  2643.     }
  2644. }
  2645.  
  2646. void rx_gotobyte( struct RexxHost *host, struct rxd_gotobyte **rxd, long action )
  2647. {
  2648.     struct rxd_gotobyte *rd = *rxd;
  2649.     struct DisplayData *DD;
  2650.  
  2651.     if(( *rxd )->arg.id )
  2652.     {
  2653.         if( ValidDD( *( *rxd )->arg.id ))
  2654.         {
  2655.             DD = *( *rxd )->arg.id;
  2656.         }
  2657.         else
  2658.         {
  2659.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2660.             (*rxd)->rc = -RC_WARN;
  2661.         }
  2662.     }
  2663.     else
  2664.         DD = AktuDD;
  2665.  
  2666.     if( !(*rxd)->rc )
  2667.     {
  2668.         if( rd->arg.pos )
  2669.             SetCursor( *rd->arg.pos, DD );
  2670.     }
  2671. }
  2672.  
  2673. void rx_getbytes( struct RexxHost *host, struct rxd_getbytes **rxd, long action )
  2674. {
  2675.     struct rxd_getbytes *rd = *rxd;
  2676.  
  2677.     switch( action )
  2678.     {
  2679.         case RXIF_ACTION:
  2680.             {
  2681.                 struct FileData *FD;
  2682.  
  2683.                 if(( *rxd )->arg.id )
  2684.                 {
  2685.                     if( ValidFD( *( *rxd )->arg.id ))
  2686.                     {
  2687.                         FD = *( *rxd )->arg.id;
  2688.                     }
  2689.                     else
  2690.                     {
  2691.                         (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2692.                         (*rxd)->rc = -RC_WARN;
  2693.                     }
  2694.                 }
  2695.                 else
  2696.                     FD = AktuDD->FD;
  2697.             
  2698.                 if( !(*rxd)->rc )
  2699.                 {
  2700.                     if(*rd->arg.number<32767)
  2701.                     {
  2702.                         if(rd->res.hexstring = AllocVec(*rd->arg.number*2+1,MEMF_ANY))
  2703.                         {
  2704.                             UBYTE *ptr=rd->res.hexstring,*bmem=FD->Mem+*rd->arg.pos;
  2705.                             long k;
  2706.                             
  2707.                             for(k=0;k<*rd->arg.number;k++)
  2708.                             {
  2709.                                 *ptr++=hexarray[*bmem >>  4];
  2710.                                 *ptr++=hexarray[*bmem++ &  0xf];
  2711.                             }
  2712.                             *ptr=0;
  2713.                         }
  2714.                     }
  2715.                     else
  2716.                     {
  2717.                         rd->rc=-RC_WARN;
  2718.                         rd->rc2=(LONG) GetStr( MSG_INFO_AREXX_NUMBERTOOHIGH );
  2719.                     }
  2720.                 }
  2721.             }
  2722.             break;
  2723.         
  2724.         case RXIF_FREE:
  2725.             if(rd->res.hexstring) FreeVec(rd->res.hexstring);
  2726.             break;
  2727.     }
  2728. }
  2729.  
  2730. void rx_setbytes( struct RexxHost *host, struct rxd_setbytes **rxd, long action )
  2731. {
  2732.     struct rxd_setbytes *rd = *rxd;
  2733.     UBYTE *ptr;
  2734.     long anz=0;
  2735.     struct FileData *FD;
  2736.  
  2737.     if(( *rxd )->arg.id )
  2738.     {
  2739.         if( ValidFD( *( *rxd )->arg.id ))
  2740.         {
  2741.             FD = *( *rxd )->arg.id;
  2742.         }
  2743.         else
  2744.         {
  2745.             (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2746.             (*rxd)->rc = -RC_WARN;
  2747.         }
  2748.     }
  2749.     else
  2750.         FD = AktuDD->FD;
  2751.  
  2752.     if( !(*rxd)->rc )
  2753.     {
  2754.         ptr=rd->arg.hexstring;
  2755.  
  2756.         while(*ptr){if(isxdigit(*ptr))anz++;ptr++;}
  2757.     
  2758.         if(ptr = AllocMem(anz/2,MEMF_ANY))
  2759.         {
  2760.             if(StringToMem(rd->arg.hexstring, ptr, anz/2))
  2761.             {
  2762.                 if(*rd->arg.pos+anz/2 <= FD->Len)
  2763.                 {
  2764.                     struct Speicher s, ps;
  2765.     
  2766.                     ps.mem = ptr;
  2767.                     ps.len = s.len = anz/2;
  2768.     
  2769.                     if(s.mem = AllocMem(s.len,MEMF_ANY))
  2770.                     {
  2771.                         AddUndoPaste(*rd->arg.pos,s,ps,FD);
  2772.                 
  2773.                             /* Sichern */
  2774.                 
  2775.                         memcpy(s.mem, FD->Mem+*rd->arg.pos, s.len);
  2776.                 
  2777.                             /* String drüber */
  2778.                 
  2779.                         memcpy(FD->Mem+*rd->arg.pos, ptr, s.len);
  2780.                     
  2781.                         AllDisplay( FD, SCROLLERNEU );
  2782.                     }
  2783.                     else
  2784.                     {
  2785.                         rd->rc=RC_WARN;
  2786.                         rd->rc2 = ERROR_NO_FREE_STORE;
  2787.                     }
  2788.                 }
  2789.                 else
  2790.                 {
  2791.                     rd->rc=-RC_WARN;
  2792.                     rd->rc2= (LONG) GetStr( MSG_INFO_AREXX_HEXSTRINGTOOLONG );
  2793.                 }
  2794.             }
  2795.             else
  2796.             {
  2797.                 rd->rc=-RC_WARN;
  2798.                 rd->rc2= (LONG) GetStr( MSG_INFO_AREXX_HEXSTRINGCONTAINSILLEGALCHARACTERS );
  2799.             }
  2800.     
  2801.             if(rd->rc)FreeMem(ptr,anz/2);
  2802.         }
  2803.     }
  2804. }
  2805.  
  2806. void rx_new( struct RexxHost *host, struct rxd_new **rxd, long action )
  2807. {
  2808.     if(( *rxd )->arg.view != FALSE )
  2809.     {
  2810.         NewDisplay( FALSE );
  2811.     }
  2812.     else if(( *rxd )->arg.window != FALSE )
  2813.     {
  2814.         OpenNewWindow( FALSE );
  2815.     }
  2816. }
  2817.  
  2818. void rx_split( struct RexxHost *host, struct rxd_split **rxd, long action )
  2819. {
  2820.     if(( *rxd )->arg.view != FALSE )
  2821.     {
  2822.         NewDisplay( TRUE );
  2823.     }
  2824.     else if(( *rxd )->arg.window != FALSE )
  2825.     {
  2826.         OpenNewWindow( TRUE );
  2827.     }
  2828. }
  2829.  
  2830. void rx_close( struct RexxHost *host, struct rxd_close **rxd, long action )
  2831. {
  2832.     BOOL Force = FALSE;
  2833.  
  2834.     if(( *rxd )->arg.force != FALSE )
  2835.         Force = TRUE;
  2836.  
  2837.     if(( *rxd )->arg.view != FALSE )
  2838.     {
  2839.         if(( *rxd )->arg.id )
  2840.         {
  2841.             if( ValidDD( *( *rxd )->arg.id ))
  2842.                 CloseView( *(*rxd)->arg.id, Force );
  2843.             else
  2844.             {
  2845.                 (*rxd)->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2846.                 (*rxd)->rc = -RC_WARN;
  2847.             }
  2848.         }
  2849.         else
  2850.             CloseView( AktuDD, Force );
  2851.     }
  2852.     else if(( *rxd )->arg.window != FALSE )
  2853.     {
  2854.         if(( *rxd )->arg.id )
  2855.         {
  2856.             if( ValidDI( *( *rxd )->arg.id ))
  2857.                 CloseDIWindow( *(*rxd)->arg.id, Force );
  2858.             else
  2859.             {
  2860.                 ( *rxd )->rc2 = (LONG) GetStr( MSG_INFO_AREXX_INVALID_ID );
  2861.                 ( *rxd )->rc = -RC_WARN;
  2862.             }
  2863.         }
  2864.         else
  2865.             CloseDIWindow( AktuDI, Force );
  2866.     }
  2867. }
  2868.  
  2869. char *geburtstagstext = "Today is my birthday! If you send me a letter with "\
  2870. "the correct date, you'll get a free registration!";    /* Höhö :-) */
  2871.  
  2872. void rx_next( struct RexxHost *host, struct rxd_next **rxd, long action )
  2873. {
  2874.     if(( *rxd )->arg.view != FALSE )
  2875.     {
  2876.         ActivateNextDisplay();
  2877.     }
  2878.     else if(( *rxd )->arg.window != FALSE )
  2879.     {
  2880.         ActivateNextWindow();
  2881.     }
  2882. }
  2883.  
  2884. void rx_previous( struct RexxHost *host, struct rxd_previous **rxd, long action )
  2885. {
  2886.     if(( *rxd )->arg.view != FALSE )
  2887.     {
  2888.         ActivatePreviousDisplay();
  2889.     }
  2890.     else if(( *rxd )->arg.window != FALSE )
  2891.     {
  2892.         ActivatePreviousWindow();
  2893.     }
  2894. }
  2895.  
  2896. void rx_lockgui( struct RexxHost *host, struct rxd_lockgui **rxd, long action )
  2897. {
  2898.     if( mainflags & MF_LOCKGUI )
  2899.         return;
  2900.  
  2901.     if(( mainflags & MF_WDWINDOWOPEN ) || ( mainflags & MF_LISTREQ ))
  2902.     {
  2903.         ( *rxd )->rc2 = (LONG) GetStr( MSG_INFO_AREXX_CANT_LOCK_GUI );
  2904.         ( *rxd )->rc = -RC_WARN;
  2905.         return;
  2906.     }
  2907.  
  2908.     mainflags |= MF_LOCKGUI;
  2909.  
  2910.     BlockMainWindow();
  2911. }
  2912.  
  2913. void rx_unlockgui( struct RexxHost *host, struct rxd_lockgui **rxd, long action )
  2914. {
  2915.     if( mainflags & MF_LOCKGUI )
  2916.     {
  2917.         mainflags &= ~MF_LOCKGUI;
  2918.  
  2919.         ReleaseMainWindow();
  2920.     }
  2921. }
  2922.  
  2923. #endif /* AREXX */
  2924.  
  2925. #ifndef RX_ALIAS_C
  2926. char *ExpandRXCommand( struct RexxHost *host, char *command )
  2927. {
  2928.     /* Insert your ALIAS-HANDLER here */
  2929.     return( NULL );
  2930. }
  2931. #endif
  2932.  
  2933.